def generate_team_at_event_status(cls, team_key, event, matches=None):
"""
Generate a dict containing team@event status information
:param team_key: Key name of the team to focus on
:param event: Event object
:param matches: Organized matches (via MatchHelper.organizeMatches) from the event, optional
"""
event_details = event.details
if not matches:
matches = event.matches
team_matches = [m for m in matches if team_key in m.team_key_names]
next_match = MatchHelper.upcomingMatches(team_matches, num=1)
last_match = MatchHelper.recentMatches(team_matches, num=1)
matches = MatchHelper.organizeMatches(matches)
return copy.deepcopy(
{
'qual':
cls._build_qual_info(team_key, event_details, matches,
event.year),
'alliance':
cls._build_alliance_info(team_key, event_details, matches),
'playoff':
cls._build_playoff_info(team_key, event_details, matches,
event.year, event.playoff_type),
'last_match_key':
last_match[0].key_name if last_match else None,
'next_match_key':
next_match[0].key_name if next_match else None,
}
) # TODO: Results are getting mixed unless copied. 2017-02-03 -fangeugene
def previous_match(self):
from helpers.match_helper import MatchHelper
recent_matches = MatchHelper.recentMatches(self.matches, 1)[0]
if recent_matches:
return recent_matches[0]
else:
return None
def send_upcoming_matches(cls, live_events):
from helpers.match_helper import MatchHelper # PJL: Hacky :P
# Causes circular import, otherwise
# https://github.com/the-blue-alliance/the-blue-alliance/pull/1098#discussion_r25128966
now = datetime.datetime.utcnow()
for event in live_events:
matches = event.matches
if not matches:
continue
last_matches = MatchHelper.recentMatches(matches, num=1)
next_matches = MatchHelper.upcomingMatches(matches, num=2)
# First, compare the difference between scheduled times of next/last match
# Send an upcoming notification if it's <10 minutes, to account for events ahead of schedule
if last_matches != []:
last_match = last_matches[0]
for i, next_match in enumerate(next_matches):
if not next_match.push_sent and last_match.time and next_match.time:
diff = next_match.time - last_match.time
if diff < datetime.timedelta(minutes=10 * (i + 1)):
cls.send_upcoming_match_notification(next_match, event)
for match in next_matches:
if match and not match.push_sent:
# Only continue sending for the next match if a push hasn't already been sent for it
if match.time is None or match.time + datetime.timedelta(minutes=-7) <= now:
# Only send notifications for matches no more than 7 minutes (average-ish match cycle time) before it's scheduled to start
# Unless, the match has no time info. Then #yolo and send it
cls.send_upcoming_match_notification(match, event)
def previous_match(self):
from helpers.match_helper import MatchHelper
recent_matches = MatchHelper.recentMatches(self.matches, 1)[0]
if recent_matches:
return recent_matches[0]
else:
return None
def post(self):
self._require_admin()
event_key = self.request.get('event_key')
matches_csv = self.request.get('matches_csv')
matches = OffseasonMatchesParser.parse(matches_csv)
event = Event.get_by_id(event_key)
matches = [Match(
id=Match.renderKeyName(
event.key.id(),
match.get("comp_level", None),
match.get("set_number", 0),
match.get("match_number", 0)),
event=event.key,
game=Match.FRC_GAMES_BY_YEAR.get(event.year, "frc_unknown"),
set_number=match.get("set_number", 0),
match_number=match.get("match_number", 0),
comp_level=match.get("comp_level", None),
team_key_names=match.get("team_key_names", None),
alliances_json=match.get("alliances_json", None)
)
for match in matches]
new_matches = MatchManipulator.createOrUpdate(matches)
try:
last_matches = MatchHelper.recentMatches(new_matches, 1)
upcoming_matches = MatchHelper.upcomingMatches(new_matches, 8)
except:
logging.warning("Computing last/upcoming matches for Firebase failed!")
try:
FirebasePusher.updateEvent(event, last_matches, upcoming_matches)
except:
logging.warning("Enqueuing Firebase push failed!")
self.redirect('/admin/event/{}'.format(event_key))
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
return self.redirect("/error/404")
event.prepAwards()
event.prepMatches()
event.prepTeams()
awards = AwardHelper.organizeAwards(event.awards)
matches = MatchHelper.organizeMatches(event.matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams/2
if num_teams%2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = sorted(zip(event.oprs,event.opr_teams), reverse=True) # sort by OPR
oprs = oprs[:14] # get the top 15 OPRs
if event.within_a_day:
matches_recent = MatchHelper.recentMatches(event.matches)
matches_upcoming = MatchHelper.upcomingMatches(event.matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = {}
qf_matches = matches['qf']
sf_matches = matches['sf']
f_matches = matches['f']
if qf_matches:
bracket_table['qf'] = MatchHelper.generateBracket(qf_matches)
if sf_matches:
bracket_table['sf'] = MatchHelper.generateBracket(sf_matches)
if f_matches:
bracket_table['f'] = MatchHelper.generateBracket(f_matches)
template_values = {
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
}
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.within_a_day:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = {}
qf_matches = matches['qf']
sf_matches = matches['sf']
f_matches = matches['f']
if qf_matches:
bracket_table['qf'] = MatchHelper.generateBracket(qf_matches)
if sf_matches:
bracket_table['sf'] = MatchHelper.generateBracket(sf_matches)
if f_matches:
bracket_table['f'] = MatchHelper.generateBracket(f_matches)
template_values = {
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
}
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, template_values)
def get(self):
self._require_registration()
current_events = filter(lambda e: e.now, EventHelper.getEventsWithinADay())
popular_teams_events = TeamHelper.getPopularTeamsEvents(current_events)
popular_team_keys = set()
for team, _ in popular_teams_events:
popular_team_keys.add(team.key.id())
for event in current_events:
event.prep_details()
event.prep_matches()
finished_matches = []
current_matches = []
upcoming_matches = []
ranks = {}
alliances = {}
for event in current_events:
if not event.details:
continue
finished_matches += MatchHelper.recentMatches(event.matches, num=1)
for i, match in enumerate(MatchHelper.upcomingMatches(event.matches, num=3)):
if not match.time:
continue
if not event.details.predictions or match.key.id() not in event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff']:
match.prediction = defaultdict(lambda: defaultdict(float))
match.bluezone_score = 0
else:
match.prediction = event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff'][match.key.id()]
match.bluezone_score = self.get_qual_bluezone_score(match.prediction) if match.comp_level == 'qm' else self.get_elim_bluezone_score(match.prediction)
if i == 0:
current_matches.append(match)
else:
upcoming_matches.append(match)
if event.details.rankings2:
for rank in event.details.rankings2:
ranks[rank['team_key']] = rank['rank']
if event.alliance_selections:
for i, alliance in enumerate(event.alliance_selections):
for pick in alliance['picks']:
alliances[pick] = i + 1
finished_matches = sorted(finished_matches, key=lambda m: m.actual_time if m.actual_time else m.time)
current_matches = sorted(current_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time)
upcoming_matches = sorted(upcoming_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time)
self.template_values.update({
'finished_matches': finished_matches,
'current_matches': current_matches,
'upcoming_matches': upcoming_matches,
'ranks': ranks,
'alliances': alliances,
'popular_team_keys': popular_team_keys,
})
self.response.out.write(jinja2_engine.render('match_suggestion.html', self.template_values))
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.within_a_day:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
self.template_values.update({
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"district_points_sorted": district_points_sorted,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, self.template_values)
def get(self):
self._require_registration()
current_events = filter(lambda e: e.now, EventHelper.getEventsWithinADay())
for event in current_events:
event.prep_details()
event.prep_matches()
finished_matches = []
current_matches = []
upcoming_matches = []
ranks = {}
alliances = {}
for event in current_events:
if not event.details:
continue
finished_matches += MatchHelper.recentMatches(event.matches, num=1)
for i, match in enumerate(MatchHelper.upcomingMatches(event.matches, num=3)):
if not match.time:
continue
if not event.details.predictions or match.key.id() not in event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff']:
match.prediction = defaultdict(lambda: defaultdict(float))
match.bluezone_score = 0
else:
match.prediction = event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff'][match.key.id()]
match.bluezone_score = self.get_qual_bluezone_score(match.prediction) if match.comp_level == 'qm' else self.get_elim_bluezone_score(match.prediction)
if i == 0:
current_matches.append(match)
else:
upcoming_matches.append(match)
if event.details.rankings2:
for rank in event.details.rankings2:
ranks[rank['team_key']] = rank['rank']
if event.alliance_selections:
for i, alliance in enumerate(event.alliance_selections):
for pick in alliance['picks']:
alliances[pick] = i + 1
finished_matches = sorted(finished_matches, key=lambda m: m.actual_time if m.actual_time else m.time)
current_matches = sorted(current_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time)
upcoming_matches = sorted(upcoming_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time)
self.template_values.update({
'finished_matches': finished_matches,
'current_matches': current_matches,
'upcoming_matches': upcoming_matches,
'ranks': ranks,
'alliances': alliances,
})
self.response.out.write(jinja2_engine.render('match_suggestion.html', self.template_values))
def send_upcoming_matches(cls, live_events):
from helpers.match_helper import MatchHelper # PJL: Hacky :P
# Causes circular import, otherwise
# https://github.com/the-blue-alliance/the-blue-alliance/pull/1098#discussion_r25128966
down_events = []
now = datetime.datetime.utcnow()
for event in live_events:
matches = event.matches
if not matches:
continue
last_matches = MatchHelper.recentMatches(matches, num=1)
next_matches = MatchHelper.upcomingMatches(matches, num=2)
# First, compare the difference between scheduled times of next/last match
# Send an upcoming notification if it's <10 minutes, to account for events ahead of schedule
if last_matches != []:
last_match = last_matches[0]
for i, next_match in enumerate(next_matches):
if not next_match.push_sent and last_match.time and next_match.time:
diff = next_match.time - last_match.time
if diff < datetime.timedelta(minutes=10 * (i + 1)):
cls.send_upcoming_match_notification(
next_match, event)
for match in next_matches:
if match and not match.push_sent:
# Only continue sending for the next match if a push hasn't already been sent for it
if match.time is None or match.time + datetime.timedelta(
minutes=-7) <= now:
# Only send notifications for matches no more than 7 minutes (average-ish match cycle time) before it's scheduled to start
# Unless, the match has no time info. Then #yolo and send it
cls.send_upcoming_match_notification(match, event)
# Determine if event is down
if cls.is_event_down(last_matches[0] if last_matches else None,
next_matches[0] if next_matches else None):
down_events.append(event.key_name)
# Update the status sitevar
status_sitevar = Sitevar.get_by_id('apistatus.down_events')
if status_sitevar is None:
status_sitevar = Sitevar(id="apistatus.down_events",
description="A list of down event keys",
values_json="[]")
old_status = status_sitevar.contents
status_sitevar.contents = down_events
status_sitevar.put()
# Clear API Response cache
ApiStatusController.clear_cache_if_needed(old_status, down_events)
def get(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
matches = event.matches
if not matches:
return
timezone = pytz.timezone(event.timezone_id)
played_matches = MatchHelper.recentMatches(matches, num=0)
unplayed_matches = MatchHelper.upcomingMatches(matches, num=10)
MatchTimePredictionHelper.predict_future_matches(played_matches, unplayed_matches, timezone, event.within_a_day)
def get(self, event_key):
import pytz
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
matches = event.matches
if not matches or not event.timezone_id:
return
timezone = pytz.timezone(event.timezone_id)
played_matches = MatchHelper.recentMatches(matches, num=0)
unplayed_matches = MatchHelper.upcomingMatches(matches,
num=len(matches))
MatchTimePredictionHelper.predict_future_matches(
event_key, played_matches, unplayed_matches, timezone,
event.within_a_day)
# Detect whether the event is down
# An event NOT down if ANY unplayed match's predicted time is within its scheduled time by a threshold and
# the last played match (if it exists) wasn't too long ago.
event_down = len(unplayed_matches) > 0
for unplayed_match in unplayed_matches:
if ((unplayed_match.predicted_time and unplayed_match.time
and unplayed_match.predicted_time <
unplayed_match.time + datetime.timedelta(minutes=30)) or
(played_matches == [] or played_matches[-1].actual_time is None
or played_matches[-1].actual_time >
datetime.datetime.now() - datetime.timedelta(minutes=30))):
event_down = False
break
status_sitevar = Sitevar.get_by_id('apistatus.down_events')
if status_sitevar is None:
status_sitevar = Sitevar(id="apistatus.down_events",
description="A list of down event keys",
values_json="[]")
old_status = set(status_sitevar.contents)
new_status = old_status.copy()
if event_down:
new_status.add(event_key)
elif event_key in new_status:
new_status.remove(event_key)
status_sitevar.contents = list(new_status)
status_sitevar.put()
# Clear API Response cache
ApiStatusController.clear_cache_if_needed(old_status, new_status)
def get(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
matches = event.matches
if not matches:
return
timezone = pytz.timezone(event.timezone_id)
played_matches = MatchHelper.recentMatches(matches, num=0)
unplayed_matches = MatchHelper.upcomingMatches(matches, num=10)
MatchTimePredictionHelper.predict_future_matches(
played_matches, unplayed_matches, timezone, event.within_a_day)
def send_upcoming_matches(cls, live_events):
from helpers.match_helper import MatchHelper # PJL: Hacky :P
# Causes circular import, otherwise
# https://github.com/the-blue-alliance/the-blue-alliance/pull/1098#discussion_r25128966
down_events = []
now = datetime.datetime.utcnow()
for event in live_events:
matches = event.matches
if not matches:
continue
last_matches = MatchHelper.recentMatches(matches, num=1)
next_matches = MatchHelper.upcomingMatches(matches, num=2)
# First, compare the difference between scheduled times of next/last match
# Send an upcoming notification if it's <10 minutes, to account for events ahead of schedule
if last_matches != []:
last_match = last_matches[0]
for i, next_match in enumerate(next_matches):
if not next_match.push_sent and last_match.time and next_match.time:
diff = next_match.time - last_match.time
if diff < datetime.timedelta(minutes=10 * (i + 1)):
cls.send_upcoming_match_notification(next_match, event)
for match in next_matches:
if match and not match.push_sent:
# Only continue sending for the next match if a push hasn't already been sent for it
if match.time is None or match.time + datetime.timedelta(minutes=-7) <= now:
# Only send notifications for matches no more than 7 minutes (average-ish match cycle time) before it's scheduled to start
# Unless, the match has no time info. Then #yolo and send it
cls.send_upcoming_match_notification(match, event)
# Determine if event is down
if cls.is_event_down(last_matches[0] if last_matches else None, next_matches[0] if next_matches else None):
down_events.append(event.key_name)
# Update the status sitevar
status_sitevar = Sitevar.get_by_id('apistatus.down_events')
if status_sitevar is None:
status_sitevar = Sitevar(id="apistatus.down_events", description="A list of down event keys", values_json="[]")
old_status = status_sitevar.contents
status_sitevar.contents = down_events
status_sitevar.put()
# Clear API Response cache
ApiStatusController.clear_cache_if_needed(old_status, down_events)
def get(self, event_key):
import pytz
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
matches = event.matches
if not matches or not event.timezone_id:
return
timezone = pytz.timezone(event.timezone_id)
played_matches = MatchHelper.recentMatches(matches, num=0)
unplayed_matches = MatchHelper.upcomingMatches(matches, num=len(matches))
MatchTimePredictionHelper.predict_future_matches(event_key, played_matches, unplayed_matches, timezone, event.within_a_day)
# Detect whether the event is down
# An event NOT down if ANY unplayed match's predicted time is within its scheduled time by a threshold and
# the last played match (if it exists) wasn't too long ago.
event_down = len(unplayed_matches) > 0
for unplayed_match in unplayed_matches:
if ((unplayed_match.predicted_time and unplayed_match.time and
unplayed_match.predicted_time < unplayed_match.time + datetime.timedelta(minutes=30)) or
(played_matches == [] or played_matches[-1].actual_time is None or played_matches[-1].actual_time > datetime.datetime.now() - datetime.timedelta(minutes=30))):
event_down = False
break
status_sitevar = Sitevar.get_by_id('apistatus.down_events')
if status_sitevar is None:
status_sitevar = Sitevar(id="apistatus.down_events", description="A list of down event keys", values_json="[]")
old_status = set(status_sitevar.contents)
new_status = old_status.copy()
if event_down:
new_status.add(event_key)
elif event_key in new_status:
new_status.remove(event_key)
status_sitevar.contents = list(new_status)
status_sitevar.put()
# Clear API Response cache
ApiStatusController.clear_cache_if_needed(old_status, new_status)
def generate_team_at_event_status(cls, team_key, event, matches=None):
"""
Generate a dict containing team@event status information
:param team_key: Key name of the team to focus on
:param event: Event object
:param matches: Organized matches (via MatchHelper.organizeMatches) from the event, optional
"""
event_details = event.details
if not matches:
matches = event.matches
team_matches = [m for m in matches if team_key in m.team_key_names]
next_match = MatchHelper.upcomingMatches(team_matches, num=1)
last_match = MatchHelper.recentMatches(team_matches, num=1)
matches = MatchHelper.organizeMatches(matches)
return copy.deepcopy({
'qual': cls._build_qual_info(team_key, event_details, matches, event.year),
'alliance': cls._build_alliance_info(team_key, event_details, matches),
'playoff': cls._build_playoff_info(team_key, event_details, matches, event.year, event.playoff_type),
'last_match_key': last_match[0].key_name if last_match else None,
'next_match_key': next_match[0].key_name if next_match else None,
}) # TODO: Results are getting mixed unless copied. 2017-02-03 -fangeugene
def get(self):
self._require_registration()
current_events = filter(lambda e: e.now, EventHelper.getEventsWithinADay())
for event in current_events:
event.prep_details()
event.prep_matches()
finished_matches = []
current_matches = []
upcoming_matches = []
ranks = {}
for event in current_events:
finished_matches += MatchHelper.recentMatches(event.matches, num=1)
for i, match in enumerate(MatchHelper.upcomingMatches(event.matches, num=3)):
if match.key.id() not in event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff']:
match.prediction = defaultdict(lambda: defaultdict())
match.bluezone_score = 0
continue
match.prediction = event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff'][match.key.id()]
match.bluezone_score = self.get_qual_bluezone_score(match.prediction) if match.comp_level == 'qm' else self.get_elim_bluezone_score(match.prediction)
if i == 0:
current_matches.append(match)
else:
upcoming_matches.append(match)
for rank in event.details.rankings2:
ranks[rank['team_key']] = rank['rank']
finished_matches = sorted(finished_matches, key=lambda m: m.actual_time if m.actual_time else m.time)
current_matches = sorted(current_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time)
upcoming_matches = sorted(upcoming_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time)
self.template_values.update({
'finished_matches': finished_matches,
'current_matches': current_matches,
'upcoming_matches': upcoming_matches,
'ranks': ranks,
})
self.response.out.write(jinja2_engine.render('match_suggestion.html', self.template_values))
def get(self, event_key):
df = DatafeedUsfirst()
event = Event.get_by_id(event_key)
new_matches = MatchManipulator.createOrUpdate(df.getMatches(event))
try:
last_matches = MatchHelper.recentMatches(new_matches, 1)
upcoming_matches = MatchHelper.upcomingMatches(new_matches, 8)
except:
logging.warning("Computing last/upcoming matches for Firebase failed!")
try:
FirebasePusher.updateEvent(event, last_matches, upcoming_matches)
except:
logging.warning("Enqueuing Firebase push failed!")
template_values = {
'matches': new_matches,
}
path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_matches_get.html')
self.response.out.write(template.render(path, template_values))
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()
] if (event.matchstats is not None
and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches,
event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(
matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(
event.district_points['points'].items(),
key=lambda (team, points): -points['total'])
event_insights = EventInsightsHelper.calculate_event_insights(
cleaned_matches, event.year)
self.template_values.update({
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
"event_insights": event_insights
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
medias_future = media_query.EventTeamsPreferredMediasQuery(
event_key).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images(
[media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[
middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()
] if (event.matchstats is not None
and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches,
event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(
matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(
event.district_points['points'].items(),
key=lambda (team, points): -points['total'])
event_insights = EventInsightsHelper.calculate_event_insights(
cleaned_matches, event.year)
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(
event.year)
self.template_values.update({
"event":
event,
"district_name":
DistrictType.type_names.get(event.event_district_enum, None),
"district_abbrev":
DistrictType.type_abbrevs.get(event.event_district_enum, None),
"matches":
matches,
"matches_recent":
matches_recent,
"matches_upcoming":
matches_upcoming,
"awards":
awards,
"teams_a":
teams_a,
"teams_b":
teams_b,
"num_teams":
num_teams,
"oprs":
oprs,
"bracket_table":
bracket_table,
"playoff_advancement":
playoff_advancement,
"district_points_sorted":
district_points_sorted,
"is_2015_playoff":
is_2015_playoff,
"event_insights_qual":
event_insights['qual'] if event_insights else None,
"event_insights_playoff":
event_insights['playoff'] if event_insights else None,
"event_insights_template":
event_insights_template,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = EventQuery(event_key).fetch()
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
event.prep_details()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
district_future = DistrictQuery(event.district_key.id()).fetch_async() if event.district_key else None
event_medias_future = media_query.EventMediasQuery(event_key).fetch_async()
status_sitevar_future = Sitevar.get_by_id_async('apistatus.down_events')
event_divisions_future = None
event_codivisions_future = None
parent_event_future = None
if event.divisions:
event_divisions_future = ndb.get_multi_async(event.divisions)
elif event.parent_event:
parent_event_future = event.parent_event.get_async()
event_codivisions_future = EventDivisionsQuery(event.parent_event.id()).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches, event)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event, event.alliance_selections)
playoff_advancement = None
playoff_template = None
double_elim_matches = None
if EventHelper.is_2015_playoff(event_key):
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
playoff_template = 'playoff_table'
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.ROUND_ROBIN_6_TEAM:
playoff_advancement = MatchHelper.generatePlayoffAdvancementRoundRobin(matches, event.year, event.alliance_selections)
playoff_template = 'playoff_round_robin_6_team'
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.BO3_FINALS or event.playoff_type == PlayoffType.BO5_FINALS:
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.DOUBLE_ELIM_8_TEAM:
double_elim_matches = MatchHelper.organizeDoubleElimMatches(matches)
district_points_sorted = None
if event.district_key and event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = event.details.insights if event.details else None
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
district = district_future.get_result() if district_future else None
event_divisions = None
if event_divisions_future:
event_divisions = [e.get_result() for e in event_divisions_future]
elif event_codivisions_future:
event_divisions = event_codivisions_future.get_result()
medias_by_slugname = MediaHelper.group_by_slugname([media for media in event_medias_future.get_result()])
has_time_predictions = matches_upcoming and any(match.predicted_time for match in matches_upcoming)
status_sitevar = status_sitevar_future.get_result()
self.template_values.update({
"event": event,
"event_down": status_sitevar and event_key in status_sitevar.contents,
"district_name": district.display_name if district else None,
"district_abbrev": district.abbreviation if district else None,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
'has_time_predictions': has_time_predictions,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"playoff_template": playoff_template,
"district_points_sorted": district_points_sorted,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
"medias_by_slugname": medias_by_slugname,
"event_divisions": event_divisions,
'parent_event': parent_event_future.get_result() if parent_event_future else None,
'double_elim_matches': double_elim_matches,
'double_elim_playoff_types': PlayoffType.DOUBLE_ELIM_TYPES,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = EventQuery(event_key).fetch()
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
event.prep_details()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
district_future = DistrictQuery(event.district_key.id()).fetch_async() if event.district_key else None
event_medias_future = media_query.EventMediasQuery(event_key).fetch_async()
status_sitevar_future = Sitevar.get_by_id_async('apistatus.down_events')
event_divisions_future = None
event_codivisions_future = None
parent_event_future = None
if event.divisions:
event_divisions_future = ndb.get_multi_async(event.divisions)
elif event.parent_event:
parent_event_future = event.parent_event.get_async()
event_codivisions_future = EventDivisionsQuery(event.parent_event.id()).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches, event)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event, event.alliance_selections)
playoff_advancement = None
playoff_template = None
double_elim_matches = None
if EventHelper.is_2015_playoff(event_key):
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
playoff_template = 'playoff_table'
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.ROUND_ROBIN_6_TEAM:
playoff_advancement = MatchHelper.generatePlayoffAdvancementRoundRobin(matches, event.year, event.alliance_selections)
playoff_template = 'playoff_round_robin_6_team'
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.BO3_FINALS or event.playoff_type == PlayoffType.BO5_FINALS:
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.DOUBLE_ELIM_8_TEAM:
double_elim_matches = MatchHelper.organizeDoubleElimMatches(matches)
district_points_sorted = None
if event.district_key and event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = event.details.insights if event.details else None
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
district = district_future.get_result() if district_future else None
event_divisions = None
if event_divisions_future:
event_divisions = [e.get_result() for e in event_divisions_future]
elif event_codivisions_future:
event_divisions = event_codivisions_future.get_result()
medias_by_slugname = MediaHelper.group_by_slugname([media for media in event_medias_future.get_result()])
has_time_predictions = matches_upcoming and any(match.predicted_time for match in matches_upcoming)
status_sitevar = status_sitevar_future.get_result()
self.template_values.update({
"event": event,
"event_down": status_sitevar and event_key in status_sitevar.contents,
"district_name": district.display_name if district else None,
"district_abbrev": district.abbreviation if district else None,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
'has_time_predictions': has_time_predictions,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"playoff_template": playoff_template,
"district_points_sorted": district_points_sorted,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
"medias_by_slugname": medias_by_slugname,
"event_divisions": event_divisions,
'parent_event': parent_event_future.get_result() if parent_event_future else None,
'double_elim_matches': double_elim_matches,
'double_elim_playoff_types': PlayoffType.DOUBLE_ELIM_TYPES,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = EventInsightsHelper.calculate_event_insights(cleaned_matches, event.year)
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
# rankings processing for ranking score per match
full_rankings = event.rankings
rankings_enhanced = event.rankings_enhanced
if rankings_enhanced is not None:
rp_index = RankingIndexes.CUMULATIVE_RANKING_SCORE[event.year]
matches_index = RankingIndexes.MATCHES_PLAYED[event.year]
ranking_criterion_name = full_rankings[0][rp_index]
full_rankings[0].append(ranking_criterion_name + "/Match*")
for row in full_rankings[1:]:
team = row[1]
if rankings_enhanced["ranking_score_per_match"] is not None:
rp_per_match = rankings_enhanced['ranking_score_per_match'][team]
row.append(rp_per_match)
if rankings_enhanced["match_offset"] is not None:
match_offset = rankings_enhanced["match_offset"][team]
if match_offset != 0:
row[matches_index] = "{} ({})".format(row[matches_index], match_offset)
self.template_values.update({
"event": event,
"district_name": DistrictType.type_names.get(event.event_district_enum, None),
"district_abbrev": DistrictType.type_abbrevs.get(event.event_district_enum, None),
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = EventQuery(event_key).fetch()
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
event.prep_details()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
district_future = DistrictQuery(event.district_key.id()).fetch_async() if event.district_key else None
event_medias_future = media_query.EventMediasQuery(event_key).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = event.details.insights if event.details else None
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
district = district_future.get_result() if district_future else None
medias_by_slugname = MediaHelper.group_by_slugname([media for media in event_medias_future.get_result()])
self.template_values.update({
"event": event,
"district_name": district.display_name if district else None,
"district_abbrev": district.abbreviation if district else None,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
"medias_by_slugname": medias_by_slugname,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
self.template_values.update({
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, self.template_values)
