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))
