def get(self, event_key=None): self._require_login() self._require_registration() if event_key is None: events = EventHelper.getEventsWithinADay() EventHelper.sort_events(events) self.template_values['events'] = events self.response.out.write(jinja2_engine.render('mytba_add_hot_matches_base.html', self.template_values)) return event = Event.get_by_id(event_key) if not event: self.abort(404) subscriptions_future = Subscription.query( Subscription.model_type==ModelType.MATCH, Subscription.notification_types==NotificationType.UPCOMING_MATCH, ancestor=self.user_bundle.account.key).fetch_async(projection=[Subscription.model_key]) matches = [] if event.matchstats and 'match_predictions' in event.matchstats: match_predictions = event.matchstats['match_predictions'] max_hotness = 0 min_hotness = float('inf') for match in event.matches: if not match.has_been_played and match.key.id() in match_predictions: prediction = match_predictions[match.key.id()] red_score = prediction['red']['score'] blue_score = prediction['blue']['score'] if red_score > blue_score: winner_score = red_score loser_score = blue_score else: winner_score = blue_score loser_score = red_score hotness = winner_score + 2.0*loser_score # Favor close high scoring matches max_hotness = max(max_hotness, hotness) min_hotness = min(min_hotness, hotness) match.hotness = hotness matches.append(match) existing_subscriptions = set() for sub in subscriptions_future.get_result(): existing_subscriptions.add(sub.model_key) hot_matches = [] for match in matches: match.hotness = 100 * (match.hotness - min_hotness) / (max_hotness - min_hotness) match.already_subscribed = match.key.id() in existing_subscriptions hot_matches.append(match) hot_matches = sorted(hot_matches, key=lambda match: -match.hotness) matches_dict = {'qm': hot_matches[:25]} self.template_values['event'] = event self.template_values['matches'] = matches_dict self.response.out.write(jinja2_engine.render('mytba_add_hot_matches.html', self.template_values))
def get(self, event_key=None): self._require_registration() if event_key is None: events = EventHelper.getEventsWithinADay() EventHelper.sort_events(events) self.template_values['events'] = events self.response.out.write(jinja2_engine.render('mytba_add_hot_matches_base.html', self.template_values)) return event = Event.get_by_id(event_key) if not event: self.abort(404) subscriptions_future = Subscription.query( Subscription.model_type==ModelType.MATCH, Subscription.notification_types==NotificationType.UPCOMING_MATCH, ancestor=self.user_bundle.account.key).fetch_async(projection=[Subscription.model_key]) matches = [] if event.matchstats and 'match_predictions' in event.matchstats: match_predictions = event.matchstats['match_predictions'] max_hotness = 0 min_hotness = float('inf') for match in event.matches: if not match.has_been_played and match.key.id() in match_predictions: prediction = match_predictions[match.key.id()] red_score = prediction['red']['score'] blue_score = prediction['blue']['score'] if red_score > blue_score: winner_score = red_score loser_score = blue_score else: winner_score = blue_score loser_score = red_score hotness = winner_score + 2.0*loser_score # Favor close high scoring matches max_hotness = max(max_hotness, hotness) min_hotness = min(min_hotness, hotness) match.hotness = hotness matches.append(match) existing_subscriptions = set() for sub in subscriptions_future.get_result(): existing_subscriptions.add(sub.model_key) hot_matches = [] for match in matches: match.hotness = 100 * (match.hotness - min_hotness) / (max_hotness - min_hotness) match.already_subscribed = match.key.id() in existing_subscriptions hot_matches.append(match) hot_matches = sorted(hot_matches, key=lambda match: -match.hotness) matches_dict = {'qm': hot_matches[:25]} self.template_values['event'] = event self.template_values['matches'] = matches_dict self.response.out.write(jinja2_engine.render('mytba_add_hot_matches.html', self.template_values))
def get(self): super(SuggestDesignsReviewController, self).get() if self.request.get('action') and self.request.get('id'): # Fast-path review self._fastpath_review() suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "robot").fetch(limit=50) reference_keys = [] for suggestion in suggestions: reference_key = suggestion.contents['reference_key'] reference = Media.create_reference( suggestion.contents['reference_type'], reference_key) reference_keys.append(reference) reference_futures = ndb.get_multi_async(reference_keys) references = map(lambda r: r.get_result(), reference_futures) suggestions_and_references = zip(suggestions, references) self.template_values.update({ "suggestions_and_references": suggestions_and_references, }) self.response.out.write(jinja2_engine.render('suggestions/suggest_designs_review.html', self.template_values))
def get(self): self._require_login("/suggest/match/video?match=%s" % self.request.get("match_key")) if not self.request.get("match_key"): self.redirect("/", abort=True) match_future = Match.get_by_id_async(self.request.get("match_key")) event_future = Event.get_by_id_async( self.request.get("match_key").split("_")[0]) match = match_future.get_result() event = event_future.get_result() if not match or not event: self.abort(404) self.template_values.update({ "status": self.request.get("status"), "event": event, "match": match, }) self.response.out.write( jinja2_engine.render('suggest_match_video.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) 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 post(self): self._require_login() status, failures = SuggestionCreator.createOffseasonEventSuggestion( author_account_key=self.user_bundle.account.key, name=self.request.get("name", None), start_date=self.request.get("start_date", None), end_date=self.request.get("end_date", None), website=self.request.get("website", None), address=self.request.get("venue_address", None), ) if status != 'success': # Don't completely wipe form data if validation fails self.template_values.update({ 'status': status, 'failures': failures, 'name': self.request.get('name', None), 'start_date': self.request.get('start_date', None), 'end_date': self.request.get('end_date', None), 'website': self.request.get('website', None), 'venue_address': self.request.get('venue_address', None), }) self.response.out.write( jinja2_engine.render('suggest_offseason_event.html', self.template_values)) else: self.redirect('/suggest/offseason?status=%s' % status)
def _render(self, year=None, explicit_year=False): events = event_query.EventListQuery(year).fetch() EventHelper.sort_events(events) week_events = EventHelper.groupByWeek(events) district_enums = set() for event in events: if event.event_district_enum is not None and event.event_district_enum != DistrictType.NO_DISTRICT: district_enums.add(event.event_district_enum) districts = [] # a tuple of (district abbrev, district name) for district_enum in district_enums: districts.append((DistrictType.type_abbrevs[district_enum], DistrictType.type_names[district_enum])) districts = sorted(districts, key=lambda d: d[1]) self.template_values.update({ "events": events, "explicit_year": explicit_year, "selected_year": year, "valid_years": self.VALID_YEARS, "week_events": week_events, "districts": districts, }) return jinja2_engine.render('event_list.html', self.template_values)
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 _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 _render(self, *args, **kw): awards_future = Award.query( Award.award_type_enum == AwardType.CHAIRMANS, Award.event_type_enum == EventType.CMP_FINALS).fetch_async() teams_by_year = defaultdict(list) for award in awards_future.get_result(): for team_key in award.team_list: teams_by_year[award.year].append(( team_key.get_async(), award.event.get_async(), award, media_query.TeamTagMediasQuery( team_key.id(), MediaTag.CHAIRMANS_VIDEO).fetch_async(), media_query.TeamTagMediasQuery( team_key.id(), MediaTag.CHAIRMANS_PRESENTATION).fetch_async(), media_query.TeamTagMediasQuery( team_key.id(), MediaTag.CHAIRMANS_ESSAY).fetch_async(), )) teams_by_year = sorted(teams_by_year.items(), key=lambda (k, v): -k) for _, tea in teams_by_year: tea.sort(key=lambda x: x[1].get_result().start_date) self.template_values.update({ 'teams_by_year': teams_by_year, }) return jinja2_engine.render('hof.html', self.template_values)
def _render(self, event_key): event = Event.get_by_id(event_key) if not event: self.abort(404) return medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async() next_match = MatchHelper.upcomingMatches(event.matches, num=1) next_match = next_match[0] if next_match else None team_and_medias = [] if next_match: # Organize medias by team teams = ndb.get_multi([ndb.Key(Team, team_key) for team_key in next_match.alliances['red']['teams'] + next_match.alliances['blue']['teams']]) image_medias = MediaHelper.get_images([media for media in medias_future.get_result()]) team_medias = defaultdict(list) for image_media in image_medias: for reference in image_media.references: team_medias[reference].append(image_media) stations = ['Red 1', 'Red 2', 'Red 3', 'Blue 1', 'Blue 2', 'Blue 3'] for i, team in enumerate(teams): team_and_medias.append((team, stations[i], team_medias.get(team.key, []))) self.template_values.update({ 'event': event, 'next_match': next_match, 'teams_and_media': team_and_medias, }) return jinja2_engine.render('nextmatch.html', self.template_values)
def get(self): suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "offseason-event") year = datetime.now().year year_events_future = EventListQuery(year).fetch_async() last_year_events_future = EventListQuery(year - 1).fetch_async() events_and_ids = [self._create_candidate_event(suggestion) for suggestion in suggestions] year_events = year_events_future.get_result() year_offseason_events = [e for e in year_events if e.event_type_enum == EventType.OFFSEASON] last_year_events = last_year_events_future.get_result() last_year_offseason_events = [e for e in last_year_events if e.event_type_enum == EventType.OFFSEASON] similar_events = [self._get_similar_events(event[1], year_offseason_events) for event in events_and_ids] similar_last_year = [self._get_similar_events(event[1], last_year_offseason_events) for event in events_and_ids] self.template_values.update({ 'success': self.request.get("success"), 'event_key': self.request.get("event_key"), 'events_and_ids': events_and_ids, 'similar_events': similar_events, 'similar_last_year': similar_last_year, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_offseason_event_review_list.html', self.template_values))
def _render(self, page=''): page_labels = [] for curPage in self.VALID_PAGES: if curPage == 1: label = '1-999' else: label = "{}'s".format((curPage - 1) * self.TEAMS_PER_PAGE) page_labels.append(label) if curPage == page: cur_page_label = label teams_1 = team_query.TeamListQuery(2 * (page - 1)).fetch_async() teams_2 = team_query.TeamListQuery(2 * (page - 1) + 1).fetch_async() teams = teams_1.get_result() + teams_2.get_result() num_teams = len(teams) middle_value = num_teams / 2 if num_teams % 2 != 0: middle_value += 1 teams_a, teams_b = teams[:middle_value], teams[middle_value:] self.template_values.update({ "teams_a": teams_a, "teams_b": teams_b, "num_teams": num_teams, "page_labels": page_labels, "cur_page_label": cur_page_label, "current_page": page }) return jinja2_engine.render('team_list.html', self.template_values)
def get(self): super(SuggestSocialMediaReviewController, self).get() suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "social-media").fetch(limit=50) reference_keys = [] for suggestion in suggestions: reference_key = suggestion.contents['reference_key'] reference = Media.create_reference( suggestion.contents['reference_type'], reference_key) reference_keys.append(reference) reference_futures = ndb.get_multi_async(reference_keys) references = map(lambda r: r.get_result(), reference_futures) suggestions_and_references = zip(suggestions, references) self.template_values.update({ "suggestions_and_references": suggestions_and_references, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_team_social_review.html', self.template_values))
def get(self): self._require_registration() self.template_values.update({ "status": self.request.get("status"), }) self.response.out.write( jinja2_engine.render('suggest_offseason_event.html', self.template_values))
def get(self): self._require_registration() if not self.request.get("event_key"): self.redirect("/", abort=True) event_future = Event.get_by_id_async(self.request.get("event_key")) event = event_future.get_result() if not event: self.abort(404) medias_future = EventMediasQuery(event.key_name).fetch_async() medias = medias_future.get_result() medias_by_slugname = MediaHelper.group_by_slugname(medias) self.template_values.update({ "status": self.request.get("status"), "medias_by_slugname": medias_by_slugname, "event": event, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_event_media.html', self.template_values))
def get(self): if self.request.get('action') and self.request.get('id'): # Fast-path review self._fastpath_review() suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "robot").fetch(limit=50) reference_keys = [] for suggestion in suggestions: reference_key = suggestion.contents['reference_key'] reference = Media.create_reference( suggestion.contents['reference_type'], reference_key) reference_keys.append(reference) reference_futures = ndb.get_multi_async(reference_keys) references = map(lambda r: r.get_result(), reference_futures) suggestions_and_references = zip(suggestions, references) self.template_values.update({ "suggestions_and_references": suggestions_and_references, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_designs_review.html', self.template_values))
def get(self): self._require_registration() self.template_values.update({ "status": self.request.get("status"), }) self.response.out.write( jinja2_engine.render('suggestions/suggest_offseason_event.html', self.template_values))
def post(self): self._require_registration() status, failures = SuggestionCreator.createOffseasonEventSuggestion( author_account_key=self.user_bundle.account.key, name=self.request.get("name", None), start_date=self.request.get("start_date", None), end_date=self.request.get("end_date", None), website=self.request.get("website", None), address=self.request.get("venue_address", None), ) if status != 'success': # Don't completely wipe form data if validation fails self.template_values.update({ 'status': status, 'failures': failures, 'name': self.request.get('name', None), 'start_date': self.request.get('start_date', None), 'end_date': self.request.get('end_date', None), 'website': self.request.get('website', None), 'venue_address': self.request.get('venue_address', None), }) self.response.out.write( jinja2_engine.render('suggest_offseason_event.html', self.template_values)) else: self.redirect('/suggest/offseason?status=%s' % status)
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 _render(self, page=''): page_labels = [] for curPage in self.VALID_PAGES: if curPage == 1: label = '1-999' else: label = "{}'s".format((curPage - 1) * 1000) page_labels.append(label) if curPage == page: cur_page_label = label teams_1 = team_query.TeamListQuery(2 * (page - 1)).fetch_async() teams_2 = team_query.TeamListQuery(2 * (page - 1) + 1).fetch_async() teams = teams_1.get_result() + teams_2.get_result() num_teams = len(teams) middle_value = num_teams / 2 if num_teams % 2 != 0: middle_value += 1 teams_a, teams_b = teams[:middle_value], teams[middle_value:] self.template_values.update({ "teams_a": teams_a, "teams_b": teams_b, "num_teams": num_teams, "page_labels": page_labels, "cur_page_label": cur_page_label, "current_page": page }) return jinja2_engine.render('team_list.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 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({ "status": self.request.get("status"), "team": team, "year": year, "medias_by_slugname": medias_by_slugname }) self.response.out.write( jinja2_engine.render('suggest_team_media.html', self.template_values))
def _render(self, *args, **kw): week_events = EventHelper.getWeekEvents() year = datetime.datetime.now().year special_webcasts = FirebasePusher.get_special_webcasts() self.template_values.update({ "events": week_events, "year": year, "any_webcast_online": any(w.get('status') == 'online' for w in special_webcasts), "special_webcasts": special_webcasts, }) insights = ndb.get_multi([ ndb.Key(Insight, Insight.renderKeyName(year, insight_name)) for insight_name in Insight.INSIGHT_NAMES.values() ]) for insight in insights: if insight: self.template_values[insight.name] = insight return jinja2_engine.render('index/index_insights.html', self.template_values)
def get(self, match_key): self._require_login() self._require_registration() match = Match.get_by_id(match_key) if not match: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key==match_key, Favorite.model_type==ModelType.MATCH, ancestor=user).get() subscription = Subscription.query(Favorite.model_key==match_key, Favorite.model_type==ModelType.MATCH, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_match_notifications] self.template_values['match'] = match self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write(jinja2_engine.render('mytba_match.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, match_key): self._require_registration() match = Match.get_by_id(match_key) if not match: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key == match_key, Favorite.model_type == ModelType.MATCH, ancestor=user).get() subscription = Subscription.query( Favorite.model_key == match_key, Favorite.model_type == ModelType.MATCH, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [ (en, NotificationType.render_names[en]) for en in NotificationType.enabled_match_notifications ] self.template_values['match'] = match self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write( jinja2_engine.render('mytba_match.html', self.template_values))
def post(self): self._require_registration() event_name = self.request.get("name", None) status, failures = SuggestionCreator.createOffseasonEventSuggestion( author_account_key=self.user_bundle.account.key, name=event_name, start_date=self.request.get("start_date", None), end_date=self.request.get("end_date", None), website=self.request.get("website", None), venue_name=self.request.get("venue_name", None), address=self.request.get("venue_address", None), city=self.request.get("venue_city", None), state=self.request.get("venue_state", None), country=self.request.get("venue_country", None) ) if status != 'success': # Don't completely wipe form data if validation fails self.template_values.update({ 'status': status, 'failures': failures, 'name': self.request.get('name', None), 'start_date': self.request.get('start_date', None), 'end_date': self.request.get('end_date', None), 'website': self.request.get('website', None), 'venue_address': self.request.get('venue_address', None), }) self.response.out.write( jinja2_engine.render('suggest_offseason_event.html', self.template_values)) else: subject, body = self._gen_notification_email(event_name) SuggestionNotifier.send_admin_alert_email(subject, body) self.redirect('/suggest/offseason?status=%s' % status)
def get(self, team_number): self._require_login() self._require_registration() team_key = 'frc{}'.format(team_number) team = Team.get_by_id(team_key) if not team: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key==team_key, Favorite.model_type==ModelType.TEAM, ancestor=user).get() subscription = Subscription.query(Favorite.model_key==team_key, Favorite.model_type==ModelType.TEAM, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_team_notifications] self.template_values['team'] = team self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write(jinja2_engine.render('mytba_team.html', self.template_values))
def get(self): suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "event_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 = [] 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') reference_futures = ndb.get_multi_async(reference_keys) references = map(lambda r: r.get_result(), reference_futures) suggestions_and_references = zip(suggestions, references) self.template_values.update({ "suggestions_and_references": suggestions_and_references, }) self.response.out.write(jinja2_engine.render('suggestions/suggest_event_media_review_list.html', self.template_values))
def _render(self, *args, **kw): year = datetime.datetime.now().year hou_event_keys_future = Event.query( Event.year == year, Event.event_type_enum.IN(EventType.CMP_EVENT_TYPES), Event.start_date <= datetime.datetime(2019, 4, 21)).fetch_async( keys_only=True) det_event_keys_future = Event.query( Event.year == year, Event.event_type_enum.IN(EventType.CMP_EVENT_TYPES), Event.start_date > datetime.datetime(2019, 4, 21)).fetch_async( keys_only=True) hou_events_futures = ndb.get_multi_async( hou_event_keys_future.get_result()) det_events_futures = ndb.get_multi_async( det_event_keys_future.get_result()) self.template_values.update({ "hou_events": [e.get_result() for e in hou_events_futures], "det_events": [e.get_result() for e in det_events_futures], "year": year, }) return jinja2_engine.render('index/index_champs.html', self.template_values)
def _render(self, year): self.template_values.update({ 'valid_years': VALID_YEARS, 'selected_year': year, }) insights = ndb.get_multi([ ndb.Key(Insight, Insight.renderKeyName(year, insight_name)) for insight_name in Insight.INSIGHT_NAMES.values() ]) last_updated = None for insight in insights: if insight: self.template_values[insight.name] = insight if last_updated is None: last_updated = insight.updated else: last_updated = max(last_updated, insight.updated) self.template_values[ 'year_specific_insights_template'] = 'event_partials/event_insights_{}.html'.format( year) self.template_values['last_updated'] = last_updated return jinja2_engine.render('insights_details.html', self.template_values)
def post(self): self._require_registration() event_name = self.request.get("name", None) status, failures = SuggestionCreator.createOffseasonEventSuggestion( author_account_key=self.user_bundle.account.key, name=event_name, start_date=self.request.get("start_date", None), end_date=self.request.get("end_date", None), website=self.request.get("website", None), venue_name=self.request.get("venue_name", None), address=self.request.get("venue_address", None), city=self.request.get("venue_city", None), state=self.request.get("venue_state", None), country=self.request.get("venue_country", None) ) if status != 'success': # Don't completely wipe form data if validation fails self.template_values.update({ 'status': status, 'failures': failures, 'name': self.request.get('name', None), 'start_date': self.request.get('start_date', None), 'end_date': self.request.get('end_date', None), 'website': self.request.get('website', None), 'venue_address': self.request.get('venue_address', None), }) self.response.out.write( jinja2_engine.render('suggestions/suggest_offseason_event.html', self.template_values)) else: subject, body = self._gen_notification_email(event_name) OutgoingNotificationHelper.send_admin_alert_email(subject, body) self.redirect('/suggest/offseason?status=%s' % status)
def _render(self, *args, **kw): awards_future = Award.query( Award.award_type_enum==AwardType.CHAIRMANS, Award.event_type_enum==EventType.CMP_FINALS).fetch_async() teams_by_year = defaultdict(list) for award in awards_future.get_result(): for team_key in award.team_list: teams_by_year[award.year].append(( team_key.get_async(), award.event.get_async(), award, media_query.TeamTagMediasQuery(team_key.id(), MediaTag.CHAIRMANS_VIDEO).fetch_async(), media_query.TeamTagMediasQuery(team_key.id(), MediaTag.CHAIRMANS_PRESENTATION).fetch_async(), media_query.TeamTagMediasQuery(team_key.id(), MediaTag.CHAIRMANS_ESSAY).fetch_async(), )) teams_by_year = sorted(teams_by_year.items(), key=lambda (k, v): -k) for _, tea in teams_by_year: tea.sort(key=lambda x: x[1].get_result().start_date) self.template_values.update({ 'teams_by_year': teams_by_year, }) return jinja2_engine.render('hof.html', self.template_values)
def get(self, team_number): self._require_registration() team_key = 'frc{}'.format(team_number) team = Team.get_by_id(team_key) if not team: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key == team_key, Favorite.model_type == ModelType.TEAM, ancestor=user).get() subscription = Subscription.query( Favorite.model_key == team_key, Favorite.model_type == ModelType.TEAM, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [ (en, NotificationType.render_names[en]) for en in NotificationType.enabled_team_notifications ] self.template_values['team'] = team self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write( jinja2_engine.render('mytba_team.html', self.template_values))
def render_team_history(cls, handler, team, is_canonical): award_futures = award_query.TeamAwardsQuery(team.key.id()).fetch_async() event_futures = event_query.TeamEventsQuery(team.key.id()).fetch_async() participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async() social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async() awards_by_event = {} for award in award_futures.get_result(): if award.event.id() not in awards_by_event: awards_by_event[award.event.id()] = [award] else: awards_by_event[award.event.id()].append(award) event_awards = [] current_event = None matches_upcoming = None short_cache = False years = set() for event in event_futures.get_result(): years.add(event.year) if event.now: current_event = event matches = match_query.TeamEventMatchesQuery(team.key.id(), event.key.id()).fetch() matches_upcoming = MatchHelper.upcomingMatches(matches) if event.within_a_day: short_cache = True if event.key_name in awards_by_event: sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name]) else: sorted_awards = [] event_awards.append((event, sorted_awards)) event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31)) last_competed = None participation_years = participation_future.get_result() if len(participation_years) > 0: last_competed = max(participation_years) current_year = datetime.date.today().year social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter) handler.template_values.update({ 'is_canonical': is_canonical, 'team': team, 'event_awards': event_awards, 'years': sorted(years), "social_medias": social_medias, 'current_event': current_event, 'matches_upcoming': matches_upcoming, 'last_competed': last_competed, 'current_year': current_year }) if short_cache: handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION return jinja2_engine.render('team_history.html', handler.template_values)
def get(self): 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 get(self): self._require_registration() current_events = filter(lambda e: e.now, EventHelper.getEventsWithinADay()) popular_teams_events = TeamHelper.getPopularTeamsEvents(current_events) popular_team_keys = set() for team, _ in popular_teams_events: popular_team_keys.add(team.key.id()) for event in current_events: event.prep_details() event.prep_matches() finished_matches = [] current_matches = [] upcoming_matches = [] ranks = {} alliances = {} for event in current_events: if not event.details: continue finished_matches += MatchHelper.recentMatches(event.matches, num=1) for i, match in enumerate(MatchHelper.upcomingMatches(event.matches, num=3)): if not match.time: continue if not event.details.predictions or match.key.id() not in event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff']: match.prediction = defaultdict(lambda: defaultdict(float)) match.bluezone_score = 0 else: match.prediction = event.details.predictions['match_predictions']['qual' if match.comp_level == 'qm' else 'playoff'][match.key.id()] match.bluezone_score = self.get_qual_bluezone_score(match.prediction) if match.comp_level == 'qm' else self.get_elim_bluezone_score(match.prediction) if i == 0: current_matches.append(match) else: upcoming_matches.append(match) if event.details.rankings2: for rank in event.details.rankings2: ranks[rank['team_key']] = rank['rank'] if event.alliance_selections: for i, alliance in enumerate(event.alliance_selections): for pick in alliance['picks']: alliances[pick] = i + 1 finished_matches = sorted(finished_matches, key=lambda m: m.actual_time if m.actual_time else m.time) current_matches = sorted(current_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time) upcoming_matches = sorted(upcoming_matches, key=lambda m: m.predicted_time if m.predicted_time else m.time) self.template_values.update({ 'finished_matches': finished_matches, 'current_matches': current_matches, 'upcoming_matches': upcoming_matches, 'ranks': ranks, 'alliances': alliances, 'popular_team_keys': popular_team_keys, }) self.response.out.write(jinja2_engine.render('match_suggestion.html', self.template_values))
def _add_admin_bar(self, html): if self._is_admin: self.template_values["cache_key"] = self.cache_key self.template_values["user_bundle"] = self._user_bundle admin_bar = jinja2_engine.render('admin_bar.html', self.template_values) return html.replace('<!-- Admin Bar -->', admin_bar.encode('utf8')) else: return html
def _render(self, *args, **kw): team_a = Team.get_by_id(self._team_key_a) if self._team_key_a else None team_b = Team.get_by_id(self._team_key_b) if self._team_key_b else None self.template_values.update({ 'team_a': team_a, 'team_b': team_b, }) return jinja2_engine.render('2champs.html', self.template_values)
def get(self): self._require_login('/account/register') # Redirects to account overview page if already registered if self.user_bundle.account.registered: self.redirect('/account') return None self.response.out.write(jinja2_engine.render('account_register.html', self.template_values))
def get(self): self._require_login() self.template_values.update({ "status": self.request.get("status"), "auth_types": AuthType.type_names, }) self.response.out.write( jinja2_engine.render('suggest_apiwrite.html', self.template_values))
def get(self): self._require_login() self.template_values.update({ "status": self.request.get("status"), "auth_types": AuthType.type_names, }) self.response.out.write( jinja2_engine.render('suggestions/suggest_apiwrite.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 render_static(page): memcache_key = "main_%s" % page html = memcache.get(memcache_key) if html is None: html = jinja2_engine.render('%s.html' % page, {}) if tba_config.CONFIG["memcache"]: memcache.set(memcache_key, html, 86400) return html
def get(self): self._require_login('/account/register') # Redirects to account overview page if already registered if self.user_bundle.account.registered: self.redirect('/account') return None self.response.out.write( jinja2_engine.render('account_register.html', self.template_values))
def get(self): self._require_registration() current_events = filter(lambda e: e.now, EventHelper.getEventsWithinADay()) self.template_values.update({ 'event_keys_json': json.dumps([e.key.id() for e in current_events]), }) self.response.out.write(jinja2_engine.render('match_timeline.html', self.template_values))
def _render(self): self.template_values.update({ 'valid_years': VALID_YEARS, }) insights = ndb.get_multi([ndb.Key(Insight, Insight.renderKeyName(0, insight_name)) for insight_name in Insight.INSIGHT_NAMES.values()]) for insight in insights: if insight: self.template_values[insight.name] = insight return jinja2_engine.render('insights.html', self.template_values)
def _add_admin_bar(self, html): if self._is_admin and self.SHOULD_ADD_ADMIN_BAR: from template_engine import jinja2_engine self.template_values["cache_key"] = self.cache_key self.template_values["return_url"] = self.request.path self.template_values["flushed"] = self.request.get("flushed") self.template_values["user_bundle"] = self._user_bundle admin_bar = jinja2_engine.render('admin_bar.html', self.template_values) return html.replace('<!-- Admin Bar -->', admin_bar.encode('utf8')) else: return html
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): suggestions = Suggestion.query().filter( Suggestion.review_state == Suggestion.REVIEW_PENDING).filter( Suggestion.target_model == "api_auth_access").fetch() suggestions = [self._ids_and_events(suggestion) for suggestion in suggestions] self.template_values.update({ 'success': self.request.get("success"), 'suggestions': suggestions, 'auth_names': AuthType.type_names, }) self.response.out.write( jinja2_engine.render('suggest_apiwrite_review_list.html', self.template_values))
def get(self): self._require_login() # Redirects if already registered redirect = self.request.get('redirect') if self.user_bundle.account.registered: if redirect: self.redirect(redirect, abort=True) else: self.redirect('/account', abort=True) self.template_values['redirect'] = redirect self.response.out.write(jinja2_engine.render('account_register.html', self.template_values))