def render_team_history(cls, handler, team, is_canonical):
award_futures = award_query.TeamAwardsQuery(team.key.id()).fetch_async()
event_futures = event_query.TeamEventsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
awards_by_event = {}
for award in award_futures.get_result():
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
years = set()
for event in event_futures.get_result():
years.add(event.year)
if event.now:
current_event = event
matches = match_query.TeamEventMatchesQuery(team.key.id(), event.key.id()).fetch()
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31))
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
handler.template_values.update({
'is_canonical': is_canonical,
'team': team,
'event_awards': event_awards,
'years': sorted(years),
"social_medias": social_medias,
'current_event': current_event,
'matches_upcoming': matches_upcoming,
'last_competed': last_competed,
'current_year': current_year
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('team_history.html', handler.template_values)
def get(self):
team_key = self.request.get("team_key")
year_str = self.request.get("year")
self._require_registration()
if not team_key or not year_str:
self.redirect("/", abort=True)
year = int(year_str)
team_future = Team.get_by_id_async(self.request.get("team_key"))
team = team_future.get_result()
if not team:
self.redirect("/", abort=True)
media_key_futures = Media.query(Media.references == team.key,
Media.year == year).fetch_async(
500, keys_only=True)
social_media_future = media_query.TeamSocialMediaQuery(
team.key.id()).fetch_async()
media_futures = ndb.get_multi_async(media_key_futures.get_result())
medias = [media_future.get_result() for media_future in media_futures]
medias_by_slugname = MediaHelper.group_by_slugname(medias)
social_medias = sorted(social_media_future.get_result(),
key=MediaHelper.social_media_sorter)
social_medias = filter(
lambda m: m.media_type_enum == MediaType.INSTAGRAM_PROFILE,
social_medias) # we only allow IG media, so only show IG profile
self.template_values.update({
"medias_by_slugname": medias_by_slugname,
"social_medias": social_medias,
"status": self.request.get("status"),
"team": team,
"year": year,
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_team_media.html',
self.template_values))
def render_team_details(cls, handler, team, year, is_canonical):
hof_award_future = award_query.TeamEventTypeAwardsQuery(team.key.id(), EventType.CMP_FINALS, AwardType.CHAIRMANS).fetch_async()
hof_video_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_VIDEO).fetch_async()
hof_presentation_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_PRESENTATION).fetch_async()
hof_essay_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_ESSAY).fetch_async()
media_future = media_query.TeamYearMediaQuery(team.key.id(), year).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
robot_future = Robot.get_by_id_async("{}_{}".format(team.key.id(), year))
team_districts_future = team_query.TeamDistrictsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
hof_awards = hof_award_future.get_result()
hof_video = hof_video_future.get_result()
hof_presentation = hof_presentation_future.get_result()
hof_essay = hof_essay_future.get_result()
hall_of_fame = {
"is_hof": len(hof_awards) > 0,
"years": [award.year for award in hof_awards],
"media": {
"video": hof_video[0].youtube_url_link if len(hof_video) > 0 else None,
"presentation": hof_presentation[0].youtube_url_link if len(hof_presentation) > 0 else None,
"essay": hof_essay[0].external_link if len(hof_essay) > 0 else None,
},
}
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(team, year, return_valid_years=True)
if not events_sorted:
return None
district_name = None
district_abbrev = None
team_district_points = None
team_districts = team_districts_future.get_result()
for district in team_districts:
if district and district.year == year:
district_abbrev = district.abbreviation
district_name = district.display_name
if district.rankings:
team_district_points = next(
iter(filter(lambda r: r['team_key'] == team.key_name,
district.rankings)), None)
break
participation = []
season_wlt_list = []
offseason_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, event_matches)
if event.event_type_enum in EventType.SEASON_EVENT_TYPES:
season_wlt_list.append(wlt)
else:
offseason_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.details and event.details.rankings2:
for ranking in event.details.rankings2:
if ranking['team_key'] == team.key.id():
team_rank = ranking['rank']
break
video_ids = []
playlist = ""
for level in Match.COMP_LEVELS:
matches = matches_organized[level]
for match in matches:
video_ids += [video.split("?")[0] for video in match.youtube_videos]
if video_ids:
playlist_title = u"{} (Team {})".format(event.name, team.team_number)
playlist = u"https://www.youtube.com/watch_videos?video_ids={}&title={}"
playlist = playlist.format(u",".join(video_ids), playlist_title)
district_points = None
if team_district_points:
district_points = next(
iter(
filter(lambda e: e['event_key'] == event.key_name,
team_district_points['event_points'])), None)
participation.append({
"event": event,
"matches": matches_organized,
"wlt": display_wlt,
"qual_avg": qual_avg,
"elim_avg": elim_avg,
"rank": team_rank,
"awards": event_awards,
"playlist": playlist,
"district_points": district_points,
})
season_wlt = None
offseason_wlt = None
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
season_wlt = {"win": 0, "loss": 0, "tie": 0}
offseason_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in season_wlt_list:
season_wlt["win"] += wlt["win"]
season_wlt["loss"] += wlt["loss"]
season_wlt["tie"] += wlt["tie"]
if season_wlt["win"] + season_wlt["loss"] + season_wlt["tie"] == 0:
season_wlt = None
for wlt in offseason_wlt_list:
offseason_wlt["win"] += wlt["win"]
offseason_wlt["loss"] += wlt["loss"]
offseason_wlt["tie"] += wlt["tie"]
if offseason_wlt["win"] + offseason_wlt["loss"] + offseason_wlt["tie"] == 0:
offseason_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname([media for media in media_future.get_result()])
avatar = MediaHelper.get_avatar(media_future.get_result())
image_medias = MediaHelper.get_images(media_future.get_result())
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
preferred_image_medias = filter(lambda x: team.key in x.preferred_references, image_medias)
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"season_wlt": season_wlt,
"offseason_wlt": offseason_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname,
"avatar": avatar,
"social_medias": social_medias,
"image_medias": image_medias,
"preferred_image_medias": preferred_image_medias,
"robot": robot_future.get_result(),
"district_name": district_name,
"district_abbrev": district_abbrev,
"last_competed": last_competed,
"current_year": current_year,
"max_year": tba_config.MAX_YEAR,
"hof": hall_of_fame,
"team_district_points": team_district_points,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render("team_details.html", handler.template_values)
def render_team_history(cls, handler, team, is_canonical):
hof_award_future = award_query.TeamEventTypeAwardsQuery(team.key.id(), EventType.CMP_FINALS, AwardType.CHAIRMANS).fetch_async()
hof_video_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_VIDEO).fetch_async()
hof_presentation_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_PRESENTATION).fetch_async()
hof_essay_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_ESSAY).fetch_async()
award_futures = award_query.TeamAwardsQuery(team.key.id()).fetch_async()
event_futures = event_query.TeamEventsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
hof_awards = hof_award_future.get_result()
hof_video = hof_video_future.get_result()
hof_presentation = hof_presentation_future.get_result()
hof_essay = hof_essay_future.get_result()
hall_of_fame = {
"is_hof": len(hof_awards) > 0,
"years": [award.year for award in hof_awards],
"media": {
"video": hof_video[0].youtube_url_link if len(hof_video) > 0 else None,
"presentation": hof_presentation[0].youtube_url_link if len(hof_presentation) > 0 else None,
"essay": hof_essay[0].external_link if len(hof_essay) > 0 else None,
},
}
awards_by_event = {}
for award in award_futures.get_result():
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
years = set()
for event in event_futures.get_result():
years.add(event.year)
if event.now:
current_event = event
matches = match_query.TeamEventMatchesQuery(team.key.id(), event.key.id()).fetch()
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31))
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"event_awards": event_awards,
"years": sorted(years),
"social_medias": social_medias,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"last_competed": last_competed,
"current_year": current_year,
"max_year": tba_config.MAX_YEAR,
"hof": hall_of_fame,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render("team_history.html", handler.template_values)
def render_team_details(cls, handler, team, year, is_canonical):
media_future = media_query.TeamYearMediaQuery(team.key.id(),
year).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(
team.key.id()).fetch_async()
robot_future = Robot.get_by_id_async('{}_{}'.format(
team.key.id(), year))
team_districts_future = team_query.TeamDistrictsQuery(
team.key.id()).fetch_async()
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(
team, year, return_valid_years=True)
if not events_sorted:
return None
participation = []
year_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(
awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(
team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(
team.key_name, event_matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if str(element[1]) == str(team.team_number):
team_rank = element[0]
break
participation.append({
'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'qual_avg': qual_avg,
'elim_avg': elim_avg,
'rank': team_rank,
'awards': event_awards
})
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(
year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(
year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname(
[media for media in media_future.get_result()])
image_medias = MediaHelper.get_images(media_future.get_result())
social_medias = sorted(social_media_future.get_result(),
key=MediaHelper.social_media_sorter)
preferred_image_medias = filter(
lambda x: team.key in x.preferred_references, image_medias)
district_name = None
district_abbrev = None
team_districts = team_districts_future.get_result()
if year in team_districts:
district_key = team_districts[year]
district_abbrev = district_key[4:]
district_type = DistrictType.abbrevs[district_abbrev]
district_name = DistrictType.type_names[district_type]
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"year_wlt": year_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname,
"social_medias": social_medias,
"image_medias": image_medias,
"preferred_image_medias": preferred_image_medias,
"robot": robot_future.get_result(),
"district_name": district_name,
"district_abbrev": district_abbrev,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('team_details.html',
handler.template_values)
def get(self):
self._require_registration()
user = self.user_bundle.account.key
now = datetime.datetime.now()
existing_access = TeamAdminAccess.query(
TeamAdminAccess.account == user,
TeamAdminAccess.expiration > now).fetch()
# If the current user is an admin, allow them to view this page for any
# team/year combination
forced_team = self.request.get("team")
forced_year = self.request.get("year")
if self.user_bundle.is_current_user_admin and forced_team and forced_year:
existing_access.append(
TeamAdminAccess(
team_number=int(forced_team),
year=int(forced_year),
))
team_keys = [
ndb.Key(Team, "frc{}".format(access.team_number))
for access in existing_access
]
if not team_keys:
self.redirect('/mod/redeem')
return
years = set([access.year for access in existing_access])
teams_future = ndb.get_multi_async(team_keys)
robot_keys = [
ndb.Key(Robot, Robot.renderKeyName(team.id(), now.year))
for team in team_keys
]
robots_future = ndb.get_multi_async(robot_keys)
social_media_futures = [
media_query.TeamSocialMediaQuery(team_key.id()).fetch_async()
for team_key in team_keys
]
team_medias_future = Media.query(Media.references.IN(team_keys),
Media.year.IN(years)).fetch_async(50)
suggestions_future = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model.IN(
self.ALLOWED_SUGGESTION_TYPES)).filter(
Suggestion.target_key.IN([k.id() for k in team_keys
])).fetch_async(limit=50)
team_num_to_team = {
team.get_result().team_number: team.get_result()
for team in teams_future
}
team_num_to_robot_name = {
int(robot.get_result().team.id()[3:]):
robot.get_result().robot_name
for robot in robots_future if robot.get_result() is not None
}
team_medias = defaultdict(lambda: defaultdict(list))
for media in team_medias_future.get_result():
for reference in media.references:
if reference in team_keys:
team_num = reference.id()[3:]
team_medias[int(team_num)][media.year].append(media)
team_social_medias = defaultdict(list)
for team_social_media_future in social_media_futures:
social_medias = team_social_media_future.get_result()
for media in social_medias:
for reference in media.references:
if reference in team_keys:
team_num = reference.id()[3:]
team_social_medias[int(team_num)].append(media)
suggestions_by_team = defaultdict(lambda: defaultdict(list))
for suggestion in suggestions_future.get_result():
if not suggestion.target_key:
continue
# Assume all the keys are team keys
team_num = suggestion.target_key[3:]
suggestions_by_team[int(team_num)][suggestion.target_model].append(
suggestion)
self.template_values.update({
"existing_access":
existing_access,
"teams":
team_num_to_team,
"robot_names_by_team":
team_num_to_robot_name,
"team_medias":
team_medias,
"team_social_medias":
team_social_medias,
"suggestions_by_team":
suggestions_by_team,
"suggestion_names":
self.SUGGESTION_NAMES,
"suggestion_review_urls":
self.SUGGESTION_REVIEW_URL,
})
self.response.out.write(
jinja2_engine.render('team_admin_dashboard.html',
self.template_values))
