def _render(self, *args, **kw):
special_webcasts_future = Sitevar.get_by_id_async('gameday.special_webcasts')
special_webcasts_temp = special_webcasts_future.get_result()
if special_webcasts_temp:
special_webcasts_temp = special_webcasts_temp.contents.get("webcasts", [])
else:
special_webcasts_temp = []
special_webcasts = []
for webcast in special_webcasts_temp:
toAppend = {}
for key, value in webcast.items():
toAppend[str(key)] = str(value)
special_webcasts.append(toAppend)
ongoing_events = []
ongoing_events_w_webcasts = []
week_events = EventHelper.getWeekEvents()
for event in week_events:
if event.now:
ongoing_events.append(ModelToDict.eventConverter(event))
if event.webcast:
ongoing_events_w_webcasts.append(ModelToDict.eventConverter(event))
webcasts_json = {
'special_webcasts': special_webcasts,
'ongoing_events': ongoing_events,
'ongoing_events_w_webcasts': ongoing_events_w_webcasts
}
self.template_values.update({
'webcasts_json': json.dumps(webcasts_json)
})
path = os.path.join(os.path.dirname(__file__), '../templates/gameday2.html')
return template.render(path, self.template_values)
def _render(self, team_key, year=None):
self._set_cache_header_length(61)
self.team = Team.get_by_id(self.team_key)
if self.team is None:
self._errors = json.dumps(
{"404": "%s team not found" % self.team_key})
self.abort(404)
events_sorted, matches_by_event_key, awards_by_event_key, _ = TeamDetailsDataFetcher.fetch(
self.team, self.year)
team_dict = ModelToDict.teamConverter(self.team)
team_dict["events"] = list()
for event in events_sorted:
event_dict = ModelToDict.eventConverter(event)
event_dict["matches"] = [
ModelToDict.matchConverter(match)
for match in matches_by_event_key.get(event.key, [])
]
event_dict["awards"] = [
ModelToDict.awardConverter(award)
for award in awards_by_event_key.get(event.key, [])
]
team_dict["events"].append(event_dict)
return json.dumps(team_dict, ensure_ascii=True)
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, team_key, event_key):
match_keys_future = Match.query(Match.event == ndb.Key(Event, self.event_key), Match.team_key_names == self.team_key).fetch_async(None, keys_only=True)
match_futures = ndb.get_multi_async(match_keys_future.get_result())
matches = [ModelToDict.matchConverter(match_future.get_result()) for match_future in match_futures]
return json.dumps(matches, ensure_ascii=True)
def _render(self, team_key):
self._set_team(team_key)
robots = TeamRobotsQuery(self.team_key).fetch()
robots_dict = {robot.year: ModelToDict.robotConverter(robot) for robot in robots}
return json.dumps(robots_dict, ensure_ascii=True)
def _render(self, event_key):
self._set_event(event_key)
matches = self.event.matches
match_dicts = [ModelToDict.matchConverter(match) for match in matches]
return json.dumps(match_dicts, ensure_ascii=True)
def _build_dict(self):
data = {}
data['message_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['match'] = ModelToDict.matchConverter(self.match)
return data
def _render(self, team_key, event_key):
award_keys_future = Award.query(Award.team_list == ndb.Key(Team, self.team_key), Award.event == ndb.Key(Event, event_key)).fetch_async(None, keys_only=True)
awards = ndb.get_multi(award_keys_future.get_result())
awards_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(awards)]
return json.dumps(awards_dicts, ensure_ascii=True)
def _render(self, event_key):
self._set_event(event_key)
matches = self.event.matches
match_dicts = [ModelToDict.matchConverter(match) for match in matches]
return json.dumps(match_dicts, ensure_ascii=True)
def _render(self, team_key):
self._set_team(team_key)
awards = TeamAwardsQuery(self.team_key).fetch()
awards_list = [ModelToDict.awardConverter(award) for award in awards]
return json.dumps(awards_list, ensure_ascii=True)
def _render(self, team_key):
self._set_team(team_key)
awards = TeamAwardsQuery(self.team_key).fetch()
awards_list = [ModelToDict.awardConverter(award) for award in awards]
return json.dumps(awards_list, ensure_ascii=True)
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, event_key):
self._set_event(event_key)
teams = filter(None, self.event.teams)
team_dicts = [ModelToDict.teamConverter(team) for team in teams]
return json.dumps(team_dicts, ensure_ascii=True)
def _render(self, team_key, year=None):
self._set_team(team_key)
medias = TeamYearMediaQuery(self.team_key, self.year).fetch()
media_list = [ModelToDict.mediaConverter(media) for media in medias]
return json.dumps(media_list, ensure_ascii=True)
def _render(self, event_key):
self._set_event(event_key)
teams = filter(None, self.event.teams)
team_dicts = [ModelToDict.teamConverter(team) for team in teams]
return json.dumps(team_dicts, ensure_ascii=True)
def _render(self, team_key):
self._set_team(team_key)
robots = TeamRobotsQuery(self.team_key).fetch()
robots_dict = {robot.year: ModelToDict.robotConverter(robot) for robot in robots}
return json.dumps(robots_dict, ensure_ascii=True)
def _render(self, team_key, year=None):
self._set_team(team_key)
medias = TeamYearMediaQuery(self.team_key, self.year).fetch()
media_list = [ModelToDict.mediaConverter(media) for media in medias]
return json.dumps(media_list, ensure_ascii=True)
def _render(self, team_key):
self._set_team(team_key)
events = TeamEventsQuery(self.team_key).fetch()
event_list = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(event_list, ensure_ascii=True)
def _render(self, event_key):
self._set_cache_header_length(60 * 60)
self._set_event(event_key)
event_dict = ModelToDict.eventConverter(self.event)
return json.dumps(event_dict, ensure_ascii=True)
def _render(self, team_key, event_key):
match_keys_future = Match.query(Match.event == ndb.Key(Event, self.event_key), Match.team_key_names == self.team_key).fetch_async(None, keys_only=True)
match_futures = ndb.get_multi_async(match_keys_future.get_result())
matches = [ModelToDict.matchConverter(match_future.get_result()) for match_future in match_futures]
return json.dumps(matches, ensure_ascii=True)
def _render(self, event_key):
self._set_cache_header_length(60 * 60)
self._set_event(event_key)
event_dict = ModelToDict.eventConverter(self.event)
return json.dumps(event_dict, ensure_ascii=True)
def _build_dict(self):
data = {}
data['message_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.match.event.get().name
data['message_data']['match'] = ModelToDict.matchConverter(self.match)
return data
def _render(self, team_key, event_key):
award_keys_future = Award.query(Award.team_list == ndb.Key(Team, self.team_key), Award.event == ndb.Key(Event, event_key)).fetch_async(None, keys_only=True)
awards = ndb.get_multi(award_keys_future.get_result())
awards_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(awards)]
return json.dumps(awards_dicts, ensure_ascii=True)
def _render(self, team_key):
self._set_team(team_key)
events = TeamEventsQuery(self.team_key).fetch()
event_list = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(event_list, ensure_ascii=True)
def data_payload(self):
from helpers.award_helper import AwardHelper
from helpers.model_to_dict import ModelToDict
return {
'awards': [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)],
'event_key': self.event.key_name
}
def _build_dict(self):
data = {}
data['notification_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['event_key'] = self.event.key_name
data['message_data']['event'] = ModelToDict.eventConverter(self.event)
return data
def _render(self, event_key):
self._set_cache_header_length(60 * 60)
self._set_event(event_key)
teams = self.event.teams
team_dicts = [ModelToDict.teamConverter(team) for team in teams]
return json.dumps(team_dicts, ensure_ascii=True)
def _render(self, team_key, year=None):
self._set_team(team_key)
events = TeamYearEventsQuery(self.team_key, self.year).fetch()
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def _render(self, team_key, year=None):
self._set_team(team_key)
events = TeamYearEventsQuery(self.team_key, self.year).fetch()
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def _render(self, event_key):
self._set_event(event_key)
award_dicts = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.event.awards)
]
return json.dumps(award_dicts, ensure_ascii=True)
def _build_dict(self):
data = {}
data['notification_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['event_key'] = self.event.key_name
data['message_data']['awards'] = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
return data
def _render(self, district_abbrev, year=None):
self._set_district(district_abbrev)
events = DistrictEventsQuery("{}{}".format(self.year, self.district_abbrev)).fetch()
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def _build_dict(self):
data = {}
data['message_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['event_key'] = self.event.key_name
data['message_data']['event'] = ModelToDict.eventConverter(self.event)
return data
def _render(self, district_abbrev, year=None):
self._set_district(district_abbrev)
district_teams = DistrictTeamsQuery("{}{}".format(self.year, self.district_abbrev)).fetch()
district_teams_dict = [ModelToDict.teamConverter(team) for team in district_teams]
return json.dumps(district_teams_dict, ensure_ascii=True)
def _render(self, event_key):
self._set_cache_header_length(60 * 60)
self._set_event(event_key)
teams = self.event.teams
team_dicts = [ModelToDict.teamConverter(team) for team in teams]
return json.dumps(team_dicts, ensure_ascii=True)
def _render(self, district_abbrev, year=None):
self._set_district(district_abbrev)
events = DistrictEventsQuery('{}{}'.format(self.year, self.district_abbrev)).fetch()
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def _render(self, district_abbrev, year=None):
self._set_district(district_abbrev)
district_teams = DistrictTeamsQuery('{}{}'.format(self.year, self.district_abbrev)).fetch()
district_teams_dict = [ModelToDict.teamConverter(team) for team in district_teams]
return json.dumps(district_teams_dict, ensure_ascii=True)
def _build_dict(self):
data = {}
data['message_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['event_key'] = self.event.key_name
data['message_data']['awards'] = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
return data
def _render(self, page_num):
page_num = int(page_num)
start = self.PAGE_SIZE * page_num
end = start + self.PAGE_SIZE
team_keys = Team.query(Team.team_number >= start, Team.team_number < end).fetch(None, keys_only=True)
team_futures = ndb.get_multi_async(team_keys)
team_list = [ModelToDict.teamConverter(team_future.get_result()) for team_future in team_futures]
return json.dumps(team_list, ensure_ascii=True)
def _render(self, page_num):
page_num = int(page_num)
start = self.PAGE_SIZE * page_num
end = start + self.PAGE_SIZE
team_keys = Team.query(Team.team_number >= start, Team.team_number < end).fetch(None, keys_only=True)
team_futures = ndb.get_multi_async(team_keys)
team_list = [ModelToDict.teamConverter(team_future.get_result()) for team_future in team_futures]
return json.dumps(team_list, ensure_ascii=True)
def get(self, model_type):
if not self.user_bundle.user:
self.response.set_status(401)
return
favorites = Favorite.query(
Favorite.model_type==int(model_type),
ancestor=ndb.Key(Account, self.user_bundle.user.user_id())).fetch()
self.response.out.write(json.dumps([ModelToDict.favoriteConverter(fav) for fav in favorites]))
def _render(self, team_key, event_key):
awards = TeamEventAwardsQuery(self.team_key, self.event_key).fetch()
awards_dicts = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(awards)
]
return json.dumps(awards_dicts, ensure_ascii=True)
def _render(self, district_abbrev, year=None):
self._set_district(district_abbrev)
event_keys = Event.query(Event.year == self.year, Event.event_district_enum == self.district).fetch(None, keys_only=True)
events = ndb.get_multi(event_keys)
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def webhook_message_data(self):
payload = self.data_payload
payload['event_name'] = self.event.name
from helpers.award_helper import AwardHelper
from helpers.model_to_dict import ModelToDict
if self.team:
payload['awards'] = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.team_awards)
]
else:
payload['awards'] = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.event.awards)
]
return payload
def _render(self, team_key):
self._set_team(team_key)
event_team_keys_future = EventTeam.query(EventTeam.team == self.team.key).fetch_async(1000, keys_only=True)
event_teams_futures = ndb.get_multi_async(event_team_keys_future.get_result())
event_keys = [event_team_future.get_result().event for event_team_future in event_teams_futures]
events_futures = ndb.get_multi_async(event_keys)
event_list = [ModelToDict.eventConverter(events_future.get_result()) for events_future in events_futures]
return json.dumps(event_list, ensure_ascii=True)
def webhook_message_data(self):
from helpers.model_to_dict import ModelToDict
payload = self.data_payload
# Remove the FCM-only keys
del payload['match_key']
payload['event_name'] = self.event.name
payload['match'] = ModelToDict.matchConverter(self.match)
return payload
def _render_android(self):
gcm_keys = self.keys[ClientType.OS_ANDROID]
data = {}
data["message_type"] = NotificationType.type_names[NotificationType.MATCH_SCORE]
data["message_data"] = {}
data["message_data"]["event_name"] = self.match.event.get().name
data["message_data"]["match"] = ModelToDict.matchConverter(self.match)
return GCMMessage(gcm_keys, data)
def _render(self, team_key, year=None):
self._write_cache_headers(61)
self.team = Team.get_by_id(self.team_key)
if self.team is None:
self._errors = json.dumps({"404": "%s team not found" % self.team_key})
self.abort(404)
events_sorted, matches_by_event_key, awards_by_event_key, _ = TeamDetailsDataFetcher.fetch(self.team, self.year)
team_dict = ModelToDict.teamConverter(self.team)
team_dict["events"] = list()
for event in events_sorted:
event_dict = ModelToDict.eventConverter(event)
event_dict["matches"] = [ModelToDict.matchConverter(match) for match in matches_by_event_key.get(event.key, [])]
event_dict["awards"] = [ModelToDict.awardConverter(award) for award in awards_by_event_key.get(event.key, [])]
team_dict["events"].append(event_dict)
return json.dumps(team_dict, ensure_ascii=True)
def test_build(self):
expected = {}
expected['message_type'] = NotificationType.type_names[NotificationType.MATCH_SCORE]
expected['message_data'] = {}
expected['message_data']['event_name'] = self.event.name
expected['message_data']['match'] = ModelToDict.matchConverter(self.match)
data = self.notification._build_dict()
self.assertEqual(expected, data)
def _render(self, year=None):
if self.year < 1992 or self.year > datetime.now().year + 1:
self._errors = json.dumps({"404": "No events found for %s" % self.year})
self.abort(404)
events = EventListQuery(self.year).fetch()
event_list = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(event_list, ensure_ascii=True)
def test_build(self):
expected = {}
expected['message_type'] = NotificationType.type_names[NotificationType.MATCH_SCORE]
expected['message_data'] = {}
expected['message_data']['event_key'] = self.event.key_name
expected['message_data']['event_name'] = self.event.name
expected['message_data']['match'] = ModelToDict.matchConverter(self.match)
data = self.notification._build_dict()
self.assertEqual(expected, data)
def test_build(self):
expected = {}
expected['notification_type'] = NotificationType.type_names[NotificationType.AWARDS]
expected['message_data'] = {}
expected['message_data']['event_name'] = self.event.name
expected['message_data']['event_key'] = self.event.key_name
expected['message_data']['awards'] = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
data = self.notification._build_dict()
self.assertEqual(expected, data)
def _render(self, team_key, year=None):
self._set_team(team_key)
event_team_keys = EventTeam.query(EventTeam.team == self.team.key, EventTeam.year == self.year).fetch(1000, keys_only=True)
event_teams = ndb.get_multi(event_team_keys)
event_keys = [event_team.event for event_team in event_teams]
events = ndb.get_multi(event_keys)
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def _render(self, year=None):
if self.year < 1992 or self.year > datetime.now().year + 1:
self._errors = json.dumps({"404": "No events found for %s" % self.year})
self.abort(404)
keys = Event.query(Event.year == self.year).fetch(1000, keys_only=True)
events = ndb.get_multi(keys)
event_list = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(event_list, ensure_ascii=True)
def _render(self, team_key, year=None):
self._set_team(team_key)
event_team_keys = EventTeam.query(EventTeam.team == self.team.key, EventTeam.year == self.year).fetch(1000, keys_only=True)
event_teams = ndb.get_multi(event_team_keys)
event_keys = [event_team.event for event_team in event_teams]
events = ndb.get_multi(event_keys)
events = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(events, ensure_ascii=True)
def _render(self, year=None):
if self.year < 1992 or self.year > datetime.now().year + 1:
self._errors = json.dumps(
{"404": "No events found for %s" % self.year})
self.abort(404)
events = EventListQuery(self.year).fetch()
event_list = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(event_list, ensure_ascii=True)
def _render(self, year=None):
if self.year < 1992 or self.year > datetime.now().year + 1:
self._errors = json.dumps(
{"404": "No events found for %s" % self.year})
self.abort(404)
keys = Event.query(Event.year == self.year).fetch(1000, keys_only=True)
events = ndb.get_multi(keys)
event_list = [ModelToDict.eventConverter(event) for event in events]
return json.dumps(event_list, ensure_ascii=True)
def _render(self,event_key):
self._set_event(event_key)
award_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
return json.dumps(award_dicts, ensure_ascii=True)
def _render(self, event_key):
self._set_event(event_key)
event_dict = ModelToDict.eventConverter(self.event)
return json.dumps(event_dict, ensure_ascii=True)
