def get(self, event_key): self._require_admin() event = Event.get_by_id(event_key) if not event: self.abort(404) event.prepAwardsMatchesTeams() reg_sitevar = Sitevar.get_by_id("cmp_registration_hacks") api_keys = ApiAuthAccess.query(ApiAuthAccess.event_list == ndb.Key(Event, event_key)).fetch() event_medias = Media.query(Media.references == event.key).fetch(500) self.template_values.update({ "event": event, "medias": event_medias, "cache_key": event_controller.EventDetail('2016nyny').cache_key.format(event.key_name), "flushed": self.request.get("flushed"), "playoff_types": PlayoffType.type_names, "write_auths": api_keys, "event_sync_disable": reg_sitevar and event_key in reg_sitevar.contents.get('divisions_to_skip', []), "set_start_day_to_last": reg_sitevar and event_key in reg_sitevar.contents.get('set_start_to_last_day', []), "skip_eventteams": reg_sitevar and event_key in reg_sitevar.contents.get('skip_eventteams', []), "event_name_override": next(iter(filter(lambda e: e.get("event") == event_key, reg_sitevar.contents.get("event_name_override", []))), {}).get("name", "") }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/event_details.html') self.response.out.write(template.render(path, self.template_values))
def _render(self, *args, **kw): avatars = [] shards = memcache.get_multi( ['2018avatars_{}'.format(i) for i in xrange(10)]) if len(shards) == 10: # If missing a shard, must refetch all for _, shard in sorted(shards.items(), key=lambda kv: kv[0]): avatars += shard if not avatars: avatars_future = Media.query( Media.media_type_enum == MediaType.AVATAR).fetch_async() avatars = sorted(avatars_future.get_result(), key=lambda a: int(a.references[0].id()[3:])) shards = {} size = len(avatars) / 10 + 1 for i in xrange(10): start = i * size end = start + size shards['2018avatars_{}'.format(i)] = avatars[start:end] memcache.set_multi(shards, 60 * 60 * 24) self.template_values.update({ 'avatars': avatars, }) return jinja2_engine.render('avatars2018.html', self.template_values)
def get(self): team_key = self.request.get("team_key") year_str = self.request.get("year") self._require_login("/suggest/team/media?team_key=%s&year=%s" % (team_key, year_str)) 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() media_key_futures = Media.query(Media.references == team.key, Media.year == year).fetch_async(500, keys_only=True) media_futures = ndb.get_multi_async(media_key_futures.get_result()) medias_by_slugname = MediaHelper.group_by_slugname([media_future.get_result() for media_future in media_futures]) self.template_values.update({ "success": self.request.get("success"), "team": team, "year": year, "medias_by_slugname": medias_by_slugname }) path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_team_media.html') self.response.out.write(template.render(path, self.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) 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) self.template_values.update({ "status": self.request.get("status"), "team": team, "year": year, "medias_by_slugname": medias_by_slugname, }) self.response.out.write(jinja2_engine.render('suggestions/suggest_team_media.html', self.template_values))
def get(self): team_key = self.request.get("team_key") self._require_registration() if not team_key: self.redirect("/", abort=True) 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 == None).fetch_async( 500, keys_only=True) media_futures = ndb.get_multi_async(media_key_futures.get_result()) medias = [media_future.get_result() for media_future in media_futures] social_medias = MediaHelper.get_socials(medias) self.template_values.update({ "status": self.request.get("status"), "team": team, "social_medias": social_medias, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_team_social_media.html', self.template_values))
def _query_async(self): team_key = self._query_args[0] year = self._query_args[1] medias = yield Media.query( Media.references == ndb.Key(Team, team_key), Media.year == year).fetch_async() raise ndb.Return(medias)
def get(self, team_number): self._require_admin() team = Team.get_by_id("frc" + team_number) if not team: self.abort(404) event_teams = EventTeam.query(EventTeam.team == team.key).fetch(500) team_medias = Media.query(Media.references == team.key).fetch(500) robots = Robot.query(Robot.team == team.key).fetch() district_teams = DistrictTeam.query( DistrictTeam.team == team.key).fetch() years_participated = sorted( TeamParticipationQuery(team.key_name).fetch()) team_medias_by_year = {} for media in team_medias: if media.year in team_medias_by_year: team_medias_by_year[media.year].append(media) else: team_medias_by_year[media.year] = [media] media_years = sorted(team_medias_by_year.keys(), reverse=True) self.template_values.update({ 'event_teams': event_teams, 'team': team, 'team_media_years': media_years, 'team_medias_by_year': team_medias_by_year, 'robots': robots, 'district_teams': district_teams, 'years_participated': years_participated, }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/team_details.html') self.response.out.write(template.render(path, self.template_values))
def get(self, event_key): self._require_admin() event = Event.get_by_id(event_key) if not event: self.abort(404) event.prepAwardsMatchesTeams() event_medias = Media.query(Media.references == event.key).fetch(500) self.template_values.update({ "event": event, "medias": event_medias, "cache_key": event_controller.EventDetail('2016nyny').cache_key.format( event.key_name), "flushed": self.request.get("flushed"), }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/event_details.html') self.response.out.write(template.render(path, self.template_values))
def _render(self, team_key, year=None): self._set_team(team_key) media_keys = Media.query(Media.references == self.team.key, Media.year == self.year).fetch(500, keys_only=True) medias = ndb.get_multi(media_keys) media_list = [ModelToDict.mediaConverter(media) for media in medias] return json.dumps(media_list, ensure_ascii=True)
def _render(self, year): year = int(year) avatars = [] shards = memcache.get_multi(['{}avatars_{}'.format(year, i) for i in xrange(10)]) if len(shards) == 10: # If missing a shard, must refetch all for _, shard in sorted(shards.items(), key=lambda kv: kv[0]): avatars += shard if not avatars: avatars_future = Media.query(Media.media_type_enum == MediaType.AVATAR, Media.year == year).fetch_async() avatars = sorted(avatars_future.get_result(), key=lambda a: int(a.references[0].id()[3:])) shards = {} size = len(avatars) / 10 + 1 for i in xrange(10): start = i * size end = start + size shards['{}avatars_{}'.format(year, i)] = avatars[start:end] memcache.set_multi(shards, 60*60*24) self.template_values.update({ 'year': year, 'avatars': avatars, }) return jinja2_engine.render('avatars.html', self.template_values)
def _query_async(self): team_key = self._query_args[0] year = self._query_args[1] medias = yield Media.query( Media.references == ndb.Key(Team, team_key), Media.year == year).fetch_async() raise ndb.Return(medias)
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 get(self): team_keys_future = Team.query().order(Team.team_number).fetch_async(keys_only=True) social_media_keys_future = Media.query(Media.year == None).fetch_async(keys_only=True) team_futures = ndb.get_multi_async(team_keys_future.get_result()) social_futures = ndb.get_multi_async(social_media_keys_future.get_result()) socials_by_team = defaultdict(dict) for social_future in social_futures: social = social_future.get_result() for reference in social.references: socials_by_team[reference.id()][social.media_type_enum] = social if team_futures: with cloudstorage.open(self.TEAMS_FILENAME_PATTERN, 'w') as teams_file: writer = csv.writer(teams_file, delimiter=',') for team_future in team_futures: team = team_future.get_result() team_row = [team.key.id(), team.nickname, team.name, team.city, team.state_prov, team.country, team.website, team.rookie_year] for social_type in MediaType.social_types: social = socials_by_team[team.key.id()].get(social_type, None) team_row.append(social.social_profile_url if social is not None else None) self._writerow_unicode(writer, team_row) self.response.out.write("Done backing up teams!")
def get(self, team_number): self._require_admin() team = Team.get_by_id("frc" + team_number) event_teams = EventTeam.query(EventTeam.team == team.key).fetch(500) team_medias = Media.query(Media.references == team.key).fetch(500) robots = Robot.query(Robot.team == team.key).fetch() district_teams = DistrictTeam.query(DistrictTeam.team == team.key).fetch() team_medias_by_year = {} for media in team_medias: if media.year in team_medias_by_year: team_medias_by_year[media.year].append(media) else: team_medias_by_year[media.year] = [media] self.template_values.update({ 'event_teams': event_teams, 'team': team, 'team_medias_by_year': team_medias_by_year, 'robots': robots, 'district_teams': district_teams, }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/team_details.html') self.response.out.write(template.render(path, self.template_values))
def get(self): team_keys_future = Team.query().order(Team.team_number).fetch_async(keys_only=True) social_media_keys_future = Media.query(Media.year == None).fetch_async(keys_only=True) team_futures = ndb.get_multi_async(team_keys_future.get_result()) social_futures = ndb.get_multi_async(social_media_keys_future.get_result()) socials_by_team = defaultdict(dict) for social_future in social_futures: social = social_future.get_result() for reference in social.references: socials_by_team[reference.id()][social.media_type_enum] = social if team_futures: with cloudstorage.open(self.TEAMS_FILENAME_PATTERN, 'w') as teams_file: writer = csv.writer(teams_file, delimiter=',') for team_future in team_futures: team = team_future.get_result() team_row = [team.key.id(), team.nickname, team.name, team.city, team.state_prov, team.country, team.website, team.rookie_year] for social_type in MediaType.social_types: social = socials_by_team[team.key.id()].get(social_type, None) team_row.append(social.social_profile_url if social is not None else None) self._writerow_unicode(writer, team_row) self.response.out.write("Done backing up teams!")
def get(self): team_key = self.request.get("team_key") self._require_registration() if not team_key: self.redirect("/", abort=True) 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 == None).fetch_async(500, keys_only=True) media_futures = ndb.get_multi_async(media_key_futures.get_result()) medias = [media_future.get_result() for media_future in media_futures] social_medias = MediaHelper.get_socials(medias) self.template_values.update({ "status": self.request.get("status"), "team": team, "social_medias": social_medias, }) self.response.out.write(jinja2_engine.render('suggestions/suggest_team_social_media.html', self.template_values))
def get(self): team_key = self.request.get("team_key") year_str = self.request.get("year") self._require_login("/suggest/team/media?team_key=%s&year=%s" % (team_key, year_str)) 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() media_key_futures = Media.query(Media.references == team.key, Media.year == year).fetch_async( 500, keys_only=True) media_futures = ndb.get_multi_async(media_key_futures.get_result()) medias_by_slugname = MediaHelper.group_by_slugname( [media_future.get_result() for media_future in media_futures]) self.template_values.update({ "success": self.request.get("success"), "team": team, "year": year, "medias_by_slugname": medias_by_slugname }) path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_team_media.html') self.response.out.write(template.render(path, self.template_values))
def _render(self, team_key, year=None): self._set_team(team_key) media_keys = Media.query(Media.references == self.team.key, Media.year == self.year).fetch(500, keys_only=True) medias = ndb.get_multi(media_keys) media_list = [ModelToDict.mediaConverter(media) for media in medias] return json.dumps(media_list, ensure_ascii=True)
def _render(self, *args, **kw): avatars_future = Media.query(Media.media_type_enum == MediaType.AVATAR).fetch_async() avatars = sorted(avatars_future.get_result(), key=lambda a: int(a.references[0].id()[3:])) self.template_values.update({ 'avatars': avatars, }) return jinja2_engine.render('avatars2018.html', self.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) 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) self.template_values.update({ "status": self.request.get("status"), "team": team, "year": year, "medias_by_slugname": medias_by_slugname, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_team_media.html', self.template_values))
def get(self, team_number): self._require_admin() team = Team.get_by_id("frc" + team_number) if not team: self.abort(404) event_teams = EventTeam.query(EventTeam.team == team.key).fetch(500) team_medias = Media.query(Media.references == team.key).fetch(500) robots = Robot.query(Robot.team == team.key).fetch() district_teams = DistrictTeam.query(DistrictTeam.team == team.key).fetch() years_participated = sorted(TeamParticipationQuery(team.key_name).fetch()) team_medias_by_year = {} for media in team_medias: if media.year in team_medias_by_year: team_medias_by_year[media.year].append(media) else: team_medias_by_year[media.year] = [media] media_years = sorted(team_medias_by_year.keys(), reverse=True) self.template_values.update({ 'event_teams': event_teams, 'team': team, 'team_media_years': media_years, 'team_medias_by_year': team_medias_by_year, 'robots': robots, 'district_teams': district_teams, 'years_participated': years_participated, }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/team_details.html') self.response.out.write(template.render(path, self.template_values))
def _query_async(self): team_key = ndb.Key(Team, self._query_args[0]) media_tag_enum = self._query_args[1] medias = yield Media.query( Media.references == team_key, Media.media_tag_enum == media_tag_enum).fetch_async() raise ndb.Return(medias)
def get(self): super(SuggestTeamMediaReviewController, self).get() suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "media").fetch(limit=50) # Quick and dirty way to group images together suggestions = sorted( suggestions, key=lambda x: 0 if x.contents['media_type_enum'] in MediaType.image_types else 1) reference_keys = [] existing_preferred_keys_futures = [] for suggestion in suggestions: reference_key = suggestion.contents['reference_key'] reference = Media.create_reference( suggestion.contents['reference_type'], reference_key) reference_keys.append(reference) if 'details_json' in suggestion.contents: suggestion.details = json.loads( suggestion.contents['details_json']) if 'image_partial' in suggestion.details: suggestion.details['thumbnail'] = suggestion.details[ 'image_partial'].replace('_l', '_m') # Find existing preferred images existing_preferred_keys_futures.append( Media.query( Media.media_type_enum.IN(MediaType.image_types), Media.references == reference, Media.preferred_references == reference, Media.year == suggestion.contents['year'], ).fetch_async(keys_only=True)) reference_futures = ndb.get_multi_async(reference_keys) existing_preferred_futures = map( lambda x: ndb.get_multi_async(x.get_result()), existing_preferred_keys_futures) references = map(lambda r: r.get_result(), reference_futures) existing_preferred = map(lambda l: map(lambda x: x.get_result(), l), existing_preferred_futures) suggestions_and_references_and_preferred = zip(suggestions, references, existing_preferred) self.template_values.update({ "suggestions_and_references_and_preferred": suggestions_and_references_and_preferred, "max_preferred": Media.MAX_PREFERRED, }) self.response.out.write( jinja2_engine.render( 'suggestions/suggest_team_media_review_list.html', self.template_values))
def _render(self, *args, **kw): avatars_future = Media.query( Media.media_type_enum == MediaType.AVATAR).fetch_async() avatars = sorted(avatars_future.get_result(), key=lambda a: int(a.references[0].id()[3:])) self.template_values.update({ 'avatars': avatars, }) return jinja2_engine.render('avatars2018.html', self.template_values)
def get(self): self._require_admin() media_count = Media.query().count() self.template_values.update({"media_count": media_count}) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/media_dashboard.html') self.response.out.write(template.render(path, self.template_values))
def get(self): self._require_admin() media_count = Media.query().count() self.template_values.update({ "media_count": media_count }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/media_dashboard.html') self.response.out.write(template.render(path, self.template_values))
def _query_async(self): event_key = self._query_args[0] year = int(event_key[:4]) event_team_keys = yield EventTeam.query(EventTeam.event == ndb.Key(Event, event_key)).fetch_async(keys_only=True) if not event_team_keys: raise ndb.Return([]) team_keys = map(lambda event_team_key: ndb.Key(Team, event_team_key.id().split('_')[1]), event_team_keys) medias = yield Media.query( Media.preferred_references.IN(team_keys), Media.year == year).fetch_async() raise ndb.Return(medias)
def _query_async(self): event_key = self._query_args[0] year = int(event_key[:4]) event_team_keys = yield EventTeam.query(EventTeam.event == ndb.Key(Event, event_key)).fetch_async(keys_only=True) if not event_team_keys: raise ndb.Return([]) team_keys = map(lambda event_team_key: ndb.Key(Team, event_team_key.id().split('_')[1]), event_team_keys) medias = yield Media.query( Media.preferred_references.IN(team_keys), Media.year == year).fetch_async() raise ndb.Return(medias)
def get(self): suggestions = ( Suggestion.query() .filter(Suggestion.review_state == Suggestion.REVIEW_PENDING) .filter(Suggestion.target_model == "media") .fetch(limit=50) ) # Quick and dirty way to group images together suggestions = sorted( suggestions, key=lambda x: 0 if x.contents["media_type_enum"] in MediaType.image_types else 1 ) reference_keys = [] existing_preferred_keys_futures = [] for suggestion in suggestions: reference_key = suggestion.contents["reference_key"] reference = Media.create_reference(suggestion.contents["reference_type"], reference_key) reference_keys.append(reference) if "details_json" in suggestion.contents: suggestion.details = json.loads(suggestion.contents["details_json"]) if "image_partial" in suggestion.details: suggestion.details["thumbnail"] = suggestion.details["image_partial"].replace("_l", "_m") # Find existing preferred images existing_preferred_keys_futures.append( Media.query( Media.media_type_enum.IN(MediaType.image_types), Media.references == reference, Media.preferred_references == reference, Media.year == suggestion.contents["year"], ).fetch_async(keys_only=True) ) reference_futures = ndb.get_multi_async(reference_keys) existing_preferred_futures = map(lambda x: ndb.get_multi_async(x.get_result()), existing_preferred_keys_futures) references = map(lambda r: r.get_result(), reference_futures) existing_preferred = map(lambda l: map(lambda x: x.get_result(), l), existing_preferred_futures) suggestions_and_references_and_preferred = zip(suggestions, references, existing_preferred) self.template_values.update( { "suggestions_and_references_and_preferred": suggestions_and_references_and_preferred, "max_preferred": Media.MAX_PREFERRED, } ) self.response.out.write( jinja2_engine.render("suggestions/suggest_team_media_review_list.html", self.template_values) )
def get(self): team_keys = Team.query().order(Team.team_number).fetch(None, keys_only=True) team_futures = ndb.get_multi_async(team_keys) social_medias = yield Media.query(Media.year == None).fetch_async() if team_futures: with cloudstorage.open(self.TEAMS_FILENAME_PATTERN, 'w') as teams_file: writer = csv.writer(teams_file, delimiter=',') for team_future in team_futures: team = team_future.get_result() self._writerow_unicode(writer, [team.key.id(), team.nickname, team.name, team.city, team.state_prov, team.country, team.website, team.rookie_year]) self.response.out.write("Done backing up teams!")
def test_reject_suggestion(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'reject::{}'.format(suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_REJECTED) medias = Media.query().fetch() self.assertEqual(len(medias), 0)
def test_reject_suggestion(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'reject::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_REJECTED) medias = Media.query().fetch() self.assertEqual(len(medias), 0)
def test_fast_path_reject(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() response = self.testapp.get( '/suggest/cad/review?action=reject&id={}'.format(suggestion_id)) response = response.follow() self.assertEqual(response.status_int, 200) self.assertEqual(response.request.GET.get('status'), 'rejected') medias = Media.query().fetch(keys_only=True) self.assertEqual(len(medias), 0) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_REJECTED)
def test_reject_suggestion(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'reject::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) # Make sure the Media object doesn't get created medias = Media.query().fetch(keys_only=True) self.assertEqual(len(medias), 0) # Make sure we mark the Suggestion as REVIEWED suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_REJECTED)
def get(self, event_key): self._require_admin() event = Event.get_by_id(event_key) if not event: self.abort(404) event.prepAwardsMatchesTeams() event_medias = Media.query(Media.references == event.key).fetch(500) self.template_values.update({ "event": event, "medias": event_medias, "cache_key": event_controller.EventDetail('2016nyny').cache_key.format(event.key_name), "flushed": self.request.get("flushed"), }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/event_details.html') self.response.out.write(template.render(path, self.template_values))
def test_reject_robot_design(self): self.loginUser() self.giveTeamAdminAccess() suggestion_id = self.createDesignSuggestion() form = self.getSuggestionForm('robot') form['accept_reject-{}'.format(suggestion_id)] = 'reject::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) # Make sure the Media object doesn't get created medias = Media.query().fetch(keys_only=True) self.assertEqual(len(medias), 0) # Make sure we mark the Suggestion as REVIEWED suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_REJECTED)
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 test_accept_suggestion(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format(suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED) medias = Media.query().fetch() self.assertEqual(len(medias), 1) media = medias[0] self.assertIsNotNone(media) self.assertEqual(media.foreign_key, 'foobar') self.assertEqual(media.media_type_enum, MediaType.YOUTUBE_VIDEO) self.assertTrue(ndb.Key(Event, '2016nyny') in media.references)
def get(self, team_number): self._require_admin() team = Team.get_by_id("frc" + team_number) event_teams = EventTeam.query(EventTeam.team == team.key).fetch(500) team_medias = Media.query(Media.references == team.key).fetch(500) team_medias_by_year = {} for media in team_medias: if media.year in team_medias_by_year: team_medias_by_year[media.year].append(media) else: team_medias_by_year[media.year] = [media] self.template_values.update( {"event_teams": event_teams, "team": team, "team_medias_by_year": team_medias_by_year} ) path = os.path.join(os.path.dirname(__file__), "../../templates/admin/team_details.html") self.response.out.write(template.render(path, self.template_values))
def test_accept_suggestion(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) # Make sure the Media object gets created media = Media.query().fetch()[0] self.assertIsNotNone(media) self.assertEqual(media.media_type_enum, MediaType.GRABCAD) self.assertEqual(media.year, 2016) self.assertListEqual(media.references, [self.team.key]) # Make sure we mark the Suggestion as REVIEWED suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED)
def test_fast_path_accept(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() response = self.testapp.get( '/suggest/cad/review?action=accept&id={}'.format(suggestion_id)) response = response.follow() self.assertEqual(response.status_int, 200) self.assertEqual(response.request.GET.get('status'), 'accepted') # Make sure the Media object gets created media = Media.query().fetch()[0] self.assertIsNotNone(media) self.assertEqual(media.media_type_enum, MediaType.GRABCAD) self.assertEqual(media.year, 2016) self.assertListEqual(media.references, [self.team.key]) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED)
def test_accept_suggestion(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED) medias = Media.query().fetch() self.assertEqual(len(medias), 1) media = medias[0] self.assertIsNotNone(media) self.assertEqual(media.foreign_key, 'foobar') self.assertEqual(media.media_type_enum, MediaType.YOUTUBE_VIDEO) self.assertTrue(ndb.Key(Event, '2016nyny') in media.references)
def test_accept_suggestion_as_preferred(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format(suggestion_id) form['preferred_keys[]'] = ['preferred::{}'.format(suggestion_id)] response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED) medias = Media.query().fetch() self.assertEqual(len(medias), 1) media = medias[0] self.assertIsNotNone(media) self.assertEqual(media.foreign_key, 'foobar') self.assertEqual(media.media_type_enum, MediaType.IMGUR) self.assertTrue(ndb.Key(Team, 'frc1124') in media.preferred_references)
def test_accept_suggestion_as_preferred(self): self.loginUser() self.givePermission() suggestion_id = self.createSuggestion() form = self.getSuggestionForm() form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format( suggestion_id) form['preferred_keys[]'] = ['preferred::{}'.format(suggestion_id)] response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED) medias = Media.query().fetch() self.assertEqual(len(medias), 1) media = medias[0] self.assertIsNotNone(media) self.assertEqual(media.foreign_key, 'foobar') self.assertEqual(media.media_type_enum, MediaType.IMGUR) self.assertTrue(ndb.Key(Team, 'frc1124') in media.preferred_references)
def test_accept_social_media(self): self.loginUser() self.giveTeamAdminAccess() suggestion_id = self.createSocialMediaSuggestion() form = self.getSuggestionForm('social-media') form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED) medias = Media.query().fetch() self.assertEqual(len(medias), 1) media = medias[0] self.assertIsNotNone(media) self.assertEqual(media.foreign_key, 'frc1124') self.assertEqual(media.media_type_enum, MediaType.TWITTER_PROFILE) self.assertTrue(ndb.Key(Team, 'frc1124') in media.references)
def test_accept_robot_design(self): self.loginUser() self.giveTeamAdminAccess() suggestion_id = self.createDesignSuggestion() form = self.getSuggestionForm('robot') form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) # Make sure the Media object gets created media = Media.query().fetch()[0] self.assertIsNotNone(media) self.assertEqual(media.media_type_enum, MediaType.GRABCAD) self.assertEqual(media.year, 2016) self.assertListEqual(media.references, [self.team.key]) # Make sure we mark the Suggestion as REVIEWED suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED)
def test_accept_social_media(self): self.loginUser() self.giveTeamAdminAccess() suggestion_id = self.createSocialMediaSuggestion() form = self.getSuggestionForm('social-media') form['accept_reject-{}'.format(suggestion_id)] = 'accept::{}'.format( suggestion_id) response = form.submit().follow() self.assertEqual(response.status_int, 200) suggestion = Suggestion.get_by_id(suggestion_id) self.assertIsNotNone(suggestion) self.assertEqual(suggestion.review_state, Suggestion.REVIEW_ACCEPTED) medias = Media.query().fetch() self.assertEqual(len(medias), 1) media = medias[0] self.assertIsNotNone(media) self.assertEqual(media.foreign_key, 'frc1124') self.assertEqual(media.media_type_enum, MediaType.TWITTER_PROFILE) self.assertTrue(ndb.Key(Team, 'frc1124') in media.references)
def get(self, event_key): self._require_admin() event = Event.get_by_id(event_key) if not event: self.abort(404) event.prepAwardsMatchesTeams() reg_sitevar = Sitevar.get_by_id("cmp_registration_hacks") api_keys = ApiAuthAccess.query( ApiAuthAccess.event_list == ndb.Key(Event, event_key)).fetch() event_medias = Media.query(Media.references == event.key).fetch(500) playoff_template = PlayoffAdvancementHelper.getPlayoffTemplate(event) elim_bracket_html = jinja2_engine.render( "bracket_partials/bracket_table.html", { "bracket_table": event.playoff_bracket, "event": event }) advancement_html = jinja2_engine.render( "playoff_partials/{}.html".format(playoff_template), { "event": event, "playoff_advancement": event.playoff_advancement, "playoff_advancement_tiebreakers": PlayoffAdvancementHelper.ROUND_ROBIN_TIEBREAKERS.get( event.year), "bracket_table": event.playoff_bracket }) if playoff_template else "None" self.template_values.update({ "event": event, "medias": event_medias, "cache_key": event_controller.EventDetail('2016nyny').cache_key.format( event.key_name), "flushed": self.request.get("flushed"), "playoff_types": PlayoffType.type_names, "write_auths": api_keys, "event_sync_disable": reg_sitevar and event_key in reg_sitevar.contents.get('divisions_to_skip', []), "set_start_day_to_last": reg_sitevar and event_key in reg_sitevar.contents.get( 'set_start_to_last_day', []), "skip_eventteams": reg_sitevar and event_key in reg_sitevar.contents.get('skip_eventteams', []), "event_name_override": next( iter( filter(lambda e: e.get("event") == event_key, reg_sitevar.contents.get("event_name_override", []))), {}).get("name", ""), "elim_bracket_html": elim_bracket_html, "advancement_html": advancement_html, }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/event_details.html') self.response.out.write(template.render(path, self.template_values))
def render_team_details(cls, handler, team, year, is_canonical): media_key_futures = Media.query(Media.references == team.key, Media.year == year).fetch_async( 500, keys_only=True) 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 media_futures = ndb.get_multi_async(media_key_futures.get_result()) 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_future.get_result() for media_future in media_futures]) 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 }) if short_cache: handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION path = os.path.join(os.path.dirname(__file__), '../templates/team_details.html') return template.render(path, handler.template_values)
def _query_async(self): event_key = ndb.Key(Event, self._query_args[0]) medias = yield Media.query(Media.references == event_key).fetch_async() raise ndb.Return(medias)
def _query_async(self): event_key = ndb.Key(Event, self._query_args[0]) medias = yield Media.query(Media.references == event_key).fetch_async() raise ndb.Return(medias)
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))
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))
def render_team_details(cls, handler, team, year, is_canonical): media_key_futures = Media.query(Media.references == team.key, Media.year == year).fetch_async(500, keys_only=True) 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 media_futures = ndb.get_multi_async(media_key_futures.get_result()) 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_future.get_result() for media_future in media_futures]) 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 }) if short_cache: handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION path = os.path.join(os.path.dirname(__file__), '../templates/team_details.html') return template.render(path, handler.template_values)
def get(self, event_key): self._require_admin() event = Event.get_by_id(event_key) if not event: self.abort(404) event.prepAwardsMatchesTeams() reg_sitevar = Sitevar.get_by_id("cmp_registration_hacks") api_keys = ApiAuthAccess.query( ApiAuthAccess.event_list == ndb.Key(Event, event_key)).fetch() event_medias = Media.query(Media.references == event.key).fetch(500) playoff_template = PlayoffAdvancementHelper.getPlayoffTemplate(event) elim_bracket_html = jinja2_engine.render( "bracket_partials/bracket_table.html", { "bracket_table": event.playoff_bracket, "event": event }) advancement_html = jinja2_engine.render( "playoff_partials/{}.html".format(playoff_template), { "event": event, "playoff_advancement": event.playoff_advancement, "playoff_advancement_tiebreakers": PlayoffAdvancementHelper.ROUND_ROBIN_TIEBREAKERS.get( event.year), "bracket_table": event.playoff_bracket }) if playoff_template else "None" organized_matches = MatchHelper.organizeMatches(event.matches) match_stats = [] for comp_level in Match.COMP_LEVELS: level_matches = organized_matches[comp_level] if not level_matches: continue match_stats.append({ 'comp_level': comp_level, 'level_name': Match.COMP_LEVELS_VERBOSE_FULL[comp_level], 'total': len(level_matches), 'played': len(filter(lambda m: m.has_been_played, level_matches)), 'unplayed': len(filter(lambda m: not m.has_been_played, level_matches)), }) self.template_values.update({ "event": event, "medias": event_medias, "flushed": self.request.get("flushed"), "playoff_types": PlayoffType.type_names, "write_auths": api_keys, "event_sync_disable": reg_sitevar and event_key in reg_sitevar.contents.get('divisions_to_skip', []), "set_start_day_to_last": reg_sitevar and event_key in reg_sitevar.contents.get( 'set_start_to_last_day', []), "skip_eventteams": reg_sitevar and event_key in reg_sitevar.contents.get('skip_eventteams', []), "event_name_override": next( iter( filter(lambda e: e.get("event") == event_key, reg_sitevar.contents.get("event_name_override", []))), {}).get("name", ""), "elim_bracket_html": elim_bracket_html, "advancement_html": advancement_html, 'match_stats': match_stats, 'deleted_count': self.request.get('deleted'), }) path = os.path.join(os.path.dirname(__file__), '../../templates/admin/event_details.html') self.response.out.write(template.render(path, self.template_values))