def store_eventteam(team, event): eventteam = EventTeam(id="{}_{}".format(event.key_name, team.key_name)) eventteam.event = event.key eventteam.team = team.key eventteam.year = event.year return EventTeamManipulator.createOrUpdate(eventteam)
def setUp(self): self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_memcache_stub() event = Event( id="2011ct", end_date=datetime.datetime(2011, 4, 2, 0, 0), event_short="ct", event_type_enum=EventType.REGIONAL, first_eid="5561", name="Northeast Utilities FIRST Connecticut Regional", start_date=datetime.datetime(2011, 3, 31, 0, 0), year=2011, venue_address="Connecticut Convention Center\r\n100 Columbus Blvd\r\nHartford, CT 06103\r\nUSA", website="http://www.ctfirst.org/ctr" ) event.put() team = Team( id="frc177", team_number=177, website="http://www.bobcatrobotics.org" ) team.put() event_team = EventTeam( id="%s_%s" % (event.key.id(), team.key.id()), event=event.key, team=team.key, year=None) event_team.put()
def post(self, event_key_id): self._require_admin() event = Event.get_by_id(event_key_id) if not event: self.redirect("/admin/event/" + event.key_name) return event_details = event.details if not event_details or not event_details.alliance_selections: # No alliance data to modify self.redirect("/admin/event/" + event.key_name) return team_in = "frc{}".format(self.request.get("backup_in")) team_out = "frc{}".format(self.request.get("backup_out")) # Make sure both teams are attending the event et_in = EventTeam.get_by_id("{}_{}".format(event.key_name, team_in)) et_out = EventTeam.get_by_id("{}_{}".format(event.key_name, team_out)) if not et_in and et_out: # Bad teams supplied self.redirect("/admin/event/" + event.key_name) return for alliance in event_details.alliance_selections: if team_out in alliance.get('picks', []): alliance['backup'] = {} alliance['backup']['in'] = team_in alliance['backup']['out'] = team_out EventDetailsManipulator.createOrUpdate(event_details) break self.redirect("/admin/event/" + event.key_name) return
def _process_request(self, request, event_key): team_keys = JSONTeamListParser.parse(request.body) event = Event.get_by_id(event_key) event_teams = [] for team_key in team_keys: if Team.get_by_id( team_key ): # Don't create EventTeams for teams that don't exist event_teams.append( EventTeam(id=event.key.id() + '_{}'.format(team_key), event=event.key, team=ndb.Key(Team, team_key), year=event.year)) # delete old eventteams old_eventteam_keys = EventTeam.query( EventTeam.event == event.key).fetch(None, keys_only=True) to_delete = set(old_eventteam_keys).difference( set([et.key for et in event_teams])) EventTeamManipulator.delete_keys(to_delete) EventTeamManipulator.createOrUpdate(event_teams) self.response.out.write( json.dumps({'Success': "Event teams successfully updated"}))
def test_eventteams_update(self): self.teams_auth.put() team_list = ['frc254', 'frc971', 'frc604'] request_body = json.dumps(team_list) request_path = '/api/trusted/v1/event/2014casj/team_list/update' sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest() response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True) self.assertEqual(response.status_code, 200) db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None) self.assertEqual(len(db_eventteams), 3) self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams]) self.assertTrue('2014casj_frc971' in [et.key.id() for et in db_eventteams]) self.assertTrue('2014casj_frc604' in [et.key.id() for et in db_eventteams]) team_list = ['frc254', 'frc100'] request_body = json.dumps(team_list) sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest() response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True) self.assertEqual(response.status_code, 200) db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None) self.assertEqual(len(db_eventteams), 2) self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams]) self.assertTrue('2014casj_frc100' in [et.key.id() for et in db_eventteams])
def test_eventteams_unknown(self): self.teams_auth.put() team_list = ['frc254', 'frc971', 'frc604'] request_body = json.dumps(team_list) # Insert teams into db, otherwise they won't get added (see 072058b) Team(id='frc254', team_number=254).put() Team(id='frc971', team_number=971).put() request_path = '/api/trusted/v1/event/2014casj/team_list/update' sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest() response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True) self.assertEqual(response.status_code, 200) db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None) self.assertEqual(len(db_eventteams), 2) self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams]) self.assertTrue('2014casj_frc971' in [et.key.id() for et in db_eventteams]) self.assertTrue('2014casj_frc604' not in [et.key.id() for et in db_eventteams]) team_list = ['frc254', 'frc100'] request_body = json.dumps(team_list) sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest() response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True) self.assertEqual(response.status_code, 200) db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None) self.assertEqual(len(db_eventteams), 1) self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams]) self.assertTrue('2014casj_frc100' not in [et.key.id() for et in db_eventteams])
def get(self, event_key): df = DatafeedFMSAPI('v2.0') event = Event.get_by_id(event_key) models = df.getEventTeams(event_key) teams = [] district_teams = [] robots = [] for group in models: # models is a list of tuples (team, districtTeam, robot) if isinstance(group[0], Team): teams.append(group[0]) if isinstance(group[1], DistrictTeam): district_teams.append(group[1]) if isinstance(group[2], Robot): robots.append(group[2]) # Write new models teams = TeamManipulator.createOrUpdate(teams) district_teams = DistrictTeamManipulator.createOrUpdate(district_teams) robots = RobotManipulator.createOrUpdate(robots) if not teams: # No teams found registered for this event teams = [] # Build EventTeams event_teams = [ EventTeam(id=event.key_name + "_" + team.key_name, event=event.key, team=team.key, year=event.year) for team in teams ] # Delete eventteams of teams that are no longer registered if event.future: existing_event_team_keys = set( EventTeam.query(EventTeam.event == event.key).fetch( 1000, keys_only=True)) event_team_keys = set([et.key for et in event_teams]) et_keys_to_delete = existing_event_team_keys.difference( event_team_keys) EventTeamManipulator.delete_keys(et_keys_to_delete) event_teams = EventTeamManipulator.createOrUpdate(event_teams) if type(event_teams) is not list: event_teams = [event_teams] template_values = { 'event': event, 'event_teams': event_teams, } path = os.path.join( os.path.dirname(__file__), '../templates/datafeeds/usfirst_event_details_get.html') self.response.out.write(template.render(path, template_values))
def get(self, year, first_eid): df = DatafeedUsfirst() df_legacy = DatafeedUsfirstLegacy() event = df.getEventDetails(first_eid) if not event: logging.warning("getEventDetails with DatafeedUsfirst for event id {} failed. Retrying with DatafeedUsfirstLegacy.".format(first_eid)) event = df_legacy.getEventDetails(int(year), first_eid) if self.request.get('event_district_enum'): event.event_district_enum = int(self.request.get('event_district_enum')) event = EventManipulator.createOrUpdate(event) teams = df.getEventTeams(int(year), first_eid) if not teams: logging.warning("getEventTeams with DatafeedUsfirst for event id {} failed. Retrying with DatafeedUsfirstLegacy.".format(first_eid)) teams = df_legacy.getEventTeams(int(year), first_eid) if not teams: logging.warning("getEventTeams with DatafeedUsfirstLegacy for event id {} failed.".format(first_eid)) teams = [] teams = TeamManipulator.createOrUpdate(teams) if teams: if type(teams) is not list: teams = [teams] event_teams = [EventTeam( id=event.key.id() + "_" + team.key.id(), event=event.key, team=team.key, year=event.year) for team in teams] # Delete eventteams of teams that unregister from an event if event.future: existing_event_team_keys = set(EventTeam.query(EventTeam.event == event.key).fetch(1000, keys_only=True)) event_team_keys = set([et.key for et in event_teams]) et_keys_to_delete = existing_event_team_keys.difference(event_team_keys) EventTeamManipulator.delete_keys(et_keys_to_delete) event_teams = EventTeamManipulator.createOrUpdate(event_teams) if type(event_teams) is not list: event_teams = [event_teams] else: event_teams = [] template_values = { 'event': event, 'event_teams': event_teams, } path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_event_details_get.html') self.response.out.write(template.render(path, template_values))
def setUp(self): app = webapp2.WSGIApplication([ webapp2.Route(r'/<team_key:>/<year:>', ApiTeamEventsController, methods=['GET']) ], debug=True) self.testapp = webtest.TestApp(app) self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_urlfetch_stub() self.testbed.init_memcache_stub() ndb.get_context().clear_cache( ) # Prevent data from leaking between tests self.testbed.init_taskqueue_stub(root_path=".") self.team = Team( id="frc281", name="Michelin / Caterpillar / Greenville Technical College /\ jcpenney / Baldor / ASME / Gastroenterology Associates /\ Laserflex South & Greenville County Schools & Greenville\ Technical Charter High School", team_number=281, nickname="EnTech GreenVillians", city="Greenville", state_prov="SC", country="USA", website="www.entech.org", ) self.team.put() self.event = Event( id="2010sc", name="Palmetto Regional", event_type_enum=EventType.REGIONAL, short_name="Palmetto", event_short="sc", year=datetime.now().year, end_date=datetime(2010, 03, 27), official=True, city='Clemson', state_prov='SC', country='USA', start_date=datetime(2010, 03, 24), ) self.event.put() self.event_team = EventTeam(team=self.team.key, event=self.event.key, year=2010) self.event_team.put()
def test_repair(self): event_team = EventTeam.get_by_id("2011ct_frc177") self.assertEqual(event_team.year, None) broken_event_teams = EventTeam.query(EventTeam.year == None).fetch() self.assertGreater(len(broken_event_teams), 0) fixed_event_teams = EventTeamRepairer.repair(broken_event_teams) fixed_event_teams = EventTeamManipulator.createOrUpdate(fixed_event_teams) event_team = EventTeam.get_by_id("2011ct_frc177") self.assertEqual(event_team.year, 2011)
def test_eventteams_update(self): self.aaa.put() team_list = ['frc254', 'frc971', 'frc604'] request_body = json.dumps(team_list) request_path = '/api/trusted/v1/event/2014casj/team_list/update' sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest() response = self.testapp.post(request_path, request_body, headers={ 'X-TBA-Auth-Id': 'tEsT_id_1', 'X-TBA-Auth-Sig': sig }, expect_errors=True) self.assertEqual(response.status_code, 200) db_eventteams = EventTeam.query( EventTeam.event == self.event.key).fetch(None) self.assertEqual(len(db_eventteams), 3) self.assertTrue( '2014casj_frc254' in [et.key.id() for et in db_eventteams]) self.assertTrue( '2014casj_frc971' in [et.key.id() for et in db_eventteams]) self.assertTrue( '2014casj_frc604' in [et.key.id() for et in db_eventteams]) team_list = ['frc254', 'frc100'] request_body = json.dumps(team_list) sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest() response = self.testapp.post(request_path, request_body, headers={ 'X-TBA-Auth-Id': 'tEsT_id_1', 'X-TBA-Auth-Sig': sig }, expect_errors=True) self.assertEqual(response.status_code, 200) db_eventteams = EventTeam.query( EventTeam.event == self.event.key).fetch(None) self.assertEqual(len(db_eventteams), 2) self.assertTrue( '2014casj_frc254' in [et.key.id() for et in db_eventteams]) self.assertTrue( '2014casj_frc100' in [et.key.id() for et in db_eventteams])
def setUp(self): self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_memcache_stub() ndb.get_context().clear_cache() # Prevent data from leaking between tests self.testbed.init_taskqueue_stub(root_path=".") self.eventteam_2015casj_frc254 = EventTeam( id='2015casj_frc254', event=ndb.Key(Event, '2015casj'), team=ndb.Key(Team, 'frc254'), year=2015, ) self.eventteam_2015cama_frc604 = EventTeam( id='2015cama_frc604', event=ndb.Key(Event, '2015cama'), team=ndb.Key(Team, 'frc604'), year=2015, ) self.eventteam_2010cama_frc604 = EventTeam( id='2010cama_frc604', event=ndb.Key(Event, '2010cama'), team=ndb.Key(Team, 'frc604'), year=2010, ) self.eventteam_2015casj_frc254.put() self.eventteam_2015cama_frc604.put() self.eventteam_2010cama_frc604.put() self.districtteam_2015fim_frc254 = DistrictTeam( id='2015fim_frc254', district=DistrictType.MICHIGAN, team=ndb.Key(Team, 'frc254'), year=2015, ) self.districtteam_2015mar_frc604 = DistrictTeam( id='2015mar_frc604', district=DistrictType.MID_ATLANTIC, team=ndb.Key(Team, 'frc604'), year=2015, ) self.districtteam_2015fim_frc254.put() self.districtteam_2015mar_frc604.put()
def get_events_and_matches_async(): if return_valid_years: event_team_keys_query = EventTeam.query(EventTeam.team == team.key) else: event_team_keys_query = EventTeam.query(EventTeam.team == team.key, EventTeam.year == year) event_team_keys = yield event_team_keys_query.fetch_async(1000, keys_only=True) event_teams = yield ndb.get_multi_async(event_team_keys) event_keys = [] for event_team in event_teams: if return_valid_years: valid_years.add(event_team.year) # valid_years is a "global" variable (defined below). Doing this removes the complexity of having to propagate the years up through the tasklet call chain. if not return_valid_years or event_team.year == year: event_keys.append(event_team.event) events, matches = yield ndb.get_multi_async(event_keys), get_matches_async(event_keys) raise ndb.Return((events, matches))
def get_team_cache_keys_and_controllers(cls, affected_refs): """ Gets cache keys and controllers that references this team """ team_keys = affected_refs['key'] event_team_keys_future = EventTeam.query( EventTeam.team.IN([team_key for team_key in team_keys ])).fetch_async(None, keys_only=True) district_team_keys_future = DistrictTeam.query( DistrictTeam.team.IN([team_key for team_key in team_keys ])).fetch_async(None, keys_only=True) event_keys = set() for et_key in event_team_keys_future.get_result(): event_key_name = et_key.id().split('_')[0] event_keys.add(ndb.Key(Event, event_key_name)) district_keys = set() for dt_key in district_team_keys_future.get_result(): district_key_name = dt_key.id().split('_')[0] district_keys.add(district_key_name) return cls._get_teams_cache_keys_and_controllers(team_keys) + \ cls._get_eventteams_cache_keys_and_controllers(event_keys) + \ cls._get_teamlist_cache_keys_and_controllers(team_keys) + \ cls._get_districtteams_cache_keys_and_controllers(district_keys, team_keys) + \ cls._queries_to_cache_keys_and_controllers(get_affected_queries.team_updated(affected_refs))
def team_updated(affected_refs): team_keys = _filter(affected_refs['key']) event_team_keys_future = EventTeam.query(EventTeam.team.IN([team_key for team_key in team_keys])).fetch_async(None, keys_only=True) district_team_keys_future = DistrictTeam.query(DistrictTeam.team.IN([team_key for team_key in team_keys])).fetch_async(None, keys_only=True) queries_and_keys = [] for team_key in team_keys: queries_and_keys.append((TeamQuery(team_key.id()))) page_num = _get_team_page_num(team_key.id()) queries_and_keys.append((TeamListQuery(page_num))) for et_key in event_team_keys_future.get_result(): year = int(et_key.id()[:4]) event_key = et_key.id().split('_')[0] page_num = _get_team_page_num(et_key.id().split('_')[1]) queries_and_keys.append((TeamListYearQuery(year, page_num))) queries_and_keys.append((EventTeamsQuery(event_key))) queries_and_keys.append((EventEventTeamsQuery(event_key))) for dt_key in district_team_keys_future.get_result(): district_key = dt_key.id().split('_')[0] queries_and_keys.append((DistrictTeamsQuery(district_key))) return queries_and_keys
def addTeamDetails(cls, team_dict, year): """ Consume a Team dict, and return it with a year's Events filtered and Matches added """ # TODO Matches should live under Events - gregmarra 1 feb 2011 # TODO Filter Events by year - gregmarra 1 feb 2011 memcache_key = "api_team_details_%s_%s" % (team_dict["key"], year) matches_list = memcache.get(memcache_key) if matches_list is None: matches = list() team = Team.get_by_id(team_dict["key"]) for e in [a.event.get() for a in EventTeam.query(EventTeam.team == team.key).fetch(1000) if a.year == year]: match_list = Match.query(Match.event == event.key, Match.team_key_names == team.key_name).fetch(500) matches.extend(match_list) matches_list = list() for match in matches: match_dict = dict() match_dict["key"] = match.key_name match_dict["event"] = match.event match_dict["comp_level"] = match.comp_level match_dict["set_number"] = match.set_number match_dict["match_number"] = match.match_number match_dict["team_keys"] = match.team_key_names match_dict["alliances"] = json.loads(match.alliances_json) matches_list.append(match_dict) # TODO: Reduce caching time before 2013 season. 2592000 is one month -gregmarra if tba_config.CONFIG["memcache"]: memcache.set(memcache_key, matches_list, 2592000) team_dict["matches"] = matches_list return team_dict
def _query_async(self): team_key = self._query_args[0] event_teams = yield EventTeam.query( EventTeam.team == ndb.Key(Team, team_key)).fetch_async() event_keys = map(lambda event_team: event_team.event, event_teams) events = yield ndb.get_multi_async(event_keys) raise ndb.Return(events)
def event_updated(affected_refs): event_keys = _filter(affected_refs['key']) years = _filter(affected_refs['year']) event_district_keys = _filter(affected_refs['district_key']) event_team_keys_future = EventTeam.query(EventTeam.event.IN([event_key for event_key in event_keys])).fetch_async(None, keys_only=True) events_future = ndb.get_multi_async(event_keys) queries_and_keys = [] for event_key in event_keys: queries_and_keys.append((EventQuery(event_key.id()))) queries_and_keys.append(EventDivisionsQuery(event_key.id())) for year in years: queries_and_keys.append((EventListQuery(year))) for event_district_key in event_district_keys: queries_and_keys.append((DistrictEventsQuery(event_district_key.id()))) for et_key in event_team_keys_future.get_result(): team_key = et_key.id().split('_')[1] year = int(et_key.id()[:4]) queries_and_keys.append((TeamEventsQuery(team_key))) queries_and_keys.append((TeamYearEventsQuery(team_key, year))) events_with_parents = filter(lambda e: e.get_result() is not None and e.get_result().parent_event is not None, events_future) parent_keys = set([e.get_result().parent_event for e in events_with_parents]) for parent_key in parent_keys: queries_and_keys.append((EventDivisionsQuery(parent_key.id()))) return queries_and_keys
def get_event_details_cache_keys_and_controllers(cls, affected_refs): """ Gets cache keys and controllers that references this EventDetails TODO: Currently inefficient and also clears event APIv2 endpoints, since alliances are served under the event. APIv3 will break alliances out. """ event_details_keys = affected_refs['key'] event_keys = set() years = set() event_district_abbrevs = set() for event_details_key in event_details_keys: event_key = ndb.Key(Event, event_details_key.id()) event_keys.add(event_key) event = event_key.get() years.add(event.year) event_district_abbrevs.add(event.event_district_abbrev) event_team_keys_future = EventTeam.query(EventTeam.event.IN([event_key for event_key in event_keys])).fetch_async(None, keys_only=True) team_keys = set() for et_key in event_team_keys_future.get_result(): team_key_name = et_key.id().split('_')[1] team_keys.add(ndb.Key(Team, team_key_name)) return cls._get_events_cache_keys_and_controllers(event_keys) + \ cls._get_event_district_points_cache_keys_and_controllers(event_keys) + \ cls._get_eventlist_cache_keys_and_controllers(years) + \ cls._get_team_events_cache_keys_and_controllers(team_keys, years) + \ cls._get_districtlist_cache_keys_and_controllers(years) + \ cls._get_district_events_cache_keys_and_controllers(event_district_abbrevs, years) + \ cls._get_district_rankings_cache_keys_and_controllers(event_district_abbrevs, years)
def update(self, event_key): """ Updates EventTeams for an event. Returns a tuple of (teams, event_teams, event_team_keys_to_delete) An EventTeam is valid iff the team: a) played a match at the event, b) the team received an award at the event, c) or the event has not yet occurred. """ event = Event.get_by_id(event_key) # Add teams from Matches and Awards team_ids = set() match_key_futures = Match.query( Match.event == event.key).fetch_async(1000, keys_only=True) award_key_futures = Award.query( Award.event == event.key).fetch_async(1000, keys_only=True) match_futures = ndb.get_multi_async(match_key_futures.get_result()) award_futures = ndb.get_multi_async(award_key_futures.get_result()) for match_future in match_futures: match = match_future.get_result() for team in match.team_key_names: team_ids.add(team) for award_future in award_futures: award = award_future.get_result() for team_key in award.team_list: team_ids.add(team_key.id()) # Create or update EventTeams teams = [Team(id=team_id, team_number=int(team_id[3:])) for team_id in team_ids] if teams: event_teams = [EventTeam(id=event_key + "_" + team.key.id(), event=event.key, team=team.key, year=event.year) for team in teams] else: event_teams = None # Delete EventTeams for teams who did not participate in the event # Only runs if event is over existing_event_teams_keys = EventTeam.query( EventTeam.event == event.key).fetch(1000, keys_only=True) existing_event_teams = ndb.get_multi(existing_event_teams_keys) existing_team_ids = set() for et in existing_event_teams: existing_team_ids.add(et.team.id()) et_keys_to_delete = set() if event.end_date is not None and event.end_date < datetime.datetime.now(): for team_id in existing_team_ids.difference(team_ids): et_key_name = "{}_{}".format(event.key_name, team_id) et_keys_to_delete.add(ndb.Key(EventTeam, et_key_name)) ndb.delete_multi(et_keys_to_delete) return teams, event_teams, et_keys_to_delete
def event_updated(affected_refs): event_keys = filter(None, affected_refs["key"]) years = filter(None, affected_refs["year"]) event_district_keys = filter(None, affected_refs["event_district_key"]) event_team_keys_future = EventTeam.query(EventTeam.event.IN([event_key for event_key in event_keys])).fetch_async( None, keys_only=True ) queries_and_keys = [] for event_key in event_keys: queries_and_keys.append((EventQuery(event_key.id()))) for year in years: queries_and_keys.append((EventListQuery(year))) for event_district_key in event_district_keys: queries_and_keys.append((DistrictEventsQuery(event_district_key))) for et_key in event_team_keys_future.get_result(): team_key = et_key.id().split("_")[1] year = int(et_key.id()[:4]) queries_and_keys.append((TeamEventsQuery(team_key))) queries_and_keys.append((TeamYearEventsQuery(team_key, year))) return queries_and_keys
def _render(self, team_number): team = Team.get_by_id("frc" + team_number) if not team: return self.redirect("/error/404") event_team_keys_future = EventTeam.query(EventTeam.team == team.key).fetch_async(1000, keys_only=True) award_keys_future = Award.query(Award.team == team.key).fetch_async(1000, keys_only=True) event_teams_futures = ndb.get_multi_async(event_team_keys_future.get_result()) awards_futures = ndb.get_multi_async(award_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) awards_by_event = {} for award_future in awards_futures: award = award_future.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 for event_future in events_futures: event = event_future.get_result() if event.now: current_event = event team_matches_future = Match.query(Match.event == event.key, Match.team_key_names == team.key_name)\ .fetch_async(500, keys_only=True) matches = ndb.get_multi(team_matches_future.get_result()) 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])['list'] 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)) years = sorted(set([et.get_result().year for et in event_teams_futures if et.get_result().year != None])) template_values = {'team': team, 'event_awards': event_awards, 'years': years, 'current_event': current_event, 'matches_upcoming': matches_upcoming} if short_cache: self._cache_expiration = self.SHORT_CACHE_EXPIRATION path = os.path.join(os.path.dirname(__file__), '../templates/team_history.html') return template.render(path, 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 media_updated(affected_refs): reference_keys = _filter(affected_refs['references']) years = _filter(affected_refs['year']) media_tags = _filter(affected_refs['media_tag_enum']) team_keys = filter(lambda x: x.kind() == 'Team', reference_keys) event_team_keys_future = EventTeam.query(EventTeam.team.IN(team_keys)).fetch_async(None, keys_only=True) if team_keys else None queries_and_keys = [] for reference_key in reference_keys: if reference_key.kind() == 'Team': for year in years: queries_and_keys.append((TeamYearMediaQuery(reference_key.id(), year))) for media_tag in media_tags: queries_and_keys.append((TeamYearTagMediasQuery(reference_key.id(), media_tag, year))) for media_tag in media_tags: queries_and_keys.append((TeamTagMediasQuery(reference_key.id(), media_tag))) queries_and_keys.append((TeamSocialMediaQuery(reference_key.id()))) if reference_key.kind() == 'Event': queries_and_keys.append((EventMediasQuery(reference_key.id()))) if event_team_keys_future: for event_team_key in event_team_keys_future.get_result(): event_key = event_team_key.id().split('_')[0] year = int(event_key[:4]) if year in years: queries_and_keys.append(EventTeamsMediasQuery(event_key)) queries_and_keys.append(EventTeamsPreferredMediasQuery(event_key)) return queries_and_keys
def getTeamInfo(self, team_key): """ Return a Team dict with basic information. """ memcache_key = "api_team_info_%s" % team_key team_dict = memcache.get(memcache_key) if team_dict is None: team = Team.get_by_id(team_key) if team is not None: team_dict = dict() team_dict["key"] = team.key_name team_dict["team_number"] = team.team_number team_dict["name"] = team.name team_dict["nickname"] = team.nickname team_dict["website"] = team.website team_dict["location"] = team.location event_teams = EventTeam.query(EventTeam.team == team.key,\ EventTeam.year == datetime.now().year)\ .fetch(1000, projection=[EventTeam.event]) team_dict["events"] = [event_team.event.id() for event_team in event_teams] try: team_dict["location"] = team.location team_dict["locality"] = team.locality team_dict["region"] = team.region team_dict["country_name"] = team.country_name except Exception, e: logging.warning("Failed to include Address for api_team_info_%s: %s" % (team_key, e)) #TODO: Reduce caching time before 2013 season. 2592000 is one month -gregmarra if tba_config.CONFIG["memcache"]: memcache.set(memcache_key, team_dict, 2592000) else: raise IndexError
def _query_async(self): team_key = self._query_args[0] year = self._query_args[1] event_teams = yield EventTeam.query( EventTeam.team == ndb.Key(Team, team_key), EventTeam.year == year).fetch_async() raise ndb.Return(event_teams)
def getTeamInfo(cls, team_key): """ Return a Team dict with basic information. """ memcache_key = "api_team_info_%s" % team_key team_dict = memcache.get(memcache_key) if team_dict is None: team = Team.get_by_id(team_key) if team is not None: team_dict = dict() team_dict["key"] = team.key_name team_dict["team_number"] = team.team_number team_dict["name"] = team.name team_dict["nickname"] = team.nickname team_dict["website"] = team.website team_dict["location"] = team.location event_teams = EventTeam.query(EventTeam.team == team.key, EventTeam.year == datetime.now().year)\ .fetch(1000, projection=[EventTeam.event]) team_dict["events"] = [event_team.event.id() for event_team in event_teams] try: team_dict["location"] = team.location team_dict["locality"] = team.locality team_dict["region"] = team.region team_dict["country_name"] = team.country_name except Exception, e: logging.warning("Failed to include Address for api_team_info_%s: %s" % (team_key, e)) # TODO: Reduce caching time before 2013 season. 2592000 is one month -gregmarra if tba_config.CONFIG["memcache"]: memcache.set(memcache_key, team_dict, 2592000) else: raise IndexError
def addTeamEvents(cls, team_dict, year): """ Consume a Team dict, and return it with a year's Events. """ memcache_key = "api_team_events_%s_%s" % (team_dict["key"], year) event_list = memcache.get(memcache_key) if event_list is None: team = Team.get_by_id(team_dict["key"]) events = [ a.event.get() for a in EventTeam.query(EventTeam.team == team.key, EventTeam. year == int(year)).fetch(1000) ] events = sorted(events, key=lambda event: event.start_date) event_list = [cls.getEventInfo(e.key_name) for e in events] for event_dict, event in zip(event_list, events): event_dict["team_wlt"] = EventHelper.getTeamWLT( team_dict["key"], event) # TODO: Reduce caching time before 2013 season. 2592000 is one month -gregmarra if tba_config.CONFIG["memcache"]: memcache.set(memcache_key, event_list, 2592000) team_dict["events"] = event_list return team_dict
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 team_updated(affected_refs): team_keys = filter(None, affected_refs['key']) event_team_keys_future = EventTeam.query( EventTeam.team.IN([team_key for team_key in team_keys ])).fetch_async(None, keys_only=True) district_team_keys_future = DistrictTeam.query( DistrictTeam.team.IN([team_key for team_key in team_keys ])).fetch_async(None, keys_only=True) queries_and_keys = [] for team_key in team_keys: queries_and_keys.append((TeamQuery(team_key.id()))) page_num = _get_team_page_num(team_key.id()) queries_and_keys.append((TeamListQuery(page_num))) for et_key in event_team_keys_future.get_result(): year = int(et_key.id()[:4]) event_key = et_key.id().split('_')[0] page_num = _get_team_page_num(et_key.id().split('_')[1]) queries_and_keys.append((TeamListYearQuery(year, page_num))) queries_and_keys.append((EventTeamsQuery(event_key))) for dt_key in district_team_keys_future.get_result(): district_key = dt_key.id().split('_')[0] queries_and_keys.append((DistrictTeamsQuery(district_key))) return queries_and_keys
def media_updated(affected_refs): reference_keys = filter(None, affected_refs['references']) years = filter(None, affected_refs['year']) team_keys = filter(lambda x: x.kind() == 'Team', reference_keys) event_team_keys_future = EventTeam.query( EventTeam.team.IN(team_keys)).fetch_async( None, keys_only=True) if team_keys else None queries_and_keys = [] for reference_key in reference_keys: if reference_key.kind() == 'Team': for year in years: queries_and_keys.append( (TeamYearMediaQuery(reference_key.id(), year))) queries_and_keys.append((TeamSocialMediaQuery(reference_key.id()))) if reference_key.kind() == 'Event': queries_and_keys.append((EventMediasQuery(reference_key.id()))) if event_team_keys_future: for event_team_key in event_team_keys_future.get_result(): event_key = event_team_key.id().split('_')[0] year = int(event_key[:4]) if year in years: queries_and_keys.append(EventTeamsMediasQuery(event_key)) queries_and_keys.append( EventTeamsPreferredMediasQuery(event_key)) return queries_and_keys
def addTeamDetails(self, team_dict, year): """ Consume a Team dict, and return it with a year's Events filtered and Matches added """ # TODO Matches should live under Events - gregmarra 1 feb 2011 # TODO Filter Events by year - gregmarra 1 feb 2011 memcache_key = "api_team_details_%s_%s" % (team_dict["key"], year) matches_list = memcache.get(memcache_key) if matches_list is None: matches = list() team = Team.get_by_id(team_dict["key"]) for e in [a.event.get() for a in EventTeam.query(EventTeam.team == team.key).fetch(1000) if a.year == year]: match_list = Match.query(Match.event == event.key, Match.team_key_names == team.key_name).fetch(500) matches.extend(match_list) matches_list = list() for match in matches: match_dict = dict() match_dict["key"] = match.key_name match_dict["event"] = match.event match_dict["comp_level"] = match.comp_level match_dict["set_number"] = match.set_number match_dict["match_number"] = match.match_number match_dict["team_keys"] = match.team_key_names match_dict["alliances"] = json.loads(match.alliances_json) matches_list.append(match_dict) #TODO: Reduce caching time before 2013 season. 2592000 is one month -gregmarra if tba_config.CONFIG["memcache"]: memcache.set(memcache_key, matches_list, 2592000) team_dict["matches"] = matches_list return team_dict
def get_event_cache_keys_and_controllers(cls, affected_refs): """ Gets cache keys and controllers that references this event """ event_keys = affected_refs['key'] years = affected_refs['year'] event_district_abbrevs = affected_refs['event_district_abbrev'] event_team_keys_future = EventTeam.query( EventTeam.event.IN([event_key for event_key in event_keys ])).fetch_async(None, keys_only=True) team_keys = set() for et_key in event_team_keys_future.get_result(): team_key_name = et_key.id().split('_')[1] team_keys.add(ndb.Key(Team, team_key_name)) return cls._get_events_cache_keys_and_controllers(event_keys) + \ cls._get_event_district_points_cache_keys_and_controllers(event_keys) + \ cls._get_eventlist_cache_keys_and_controllers(years) + \ cls._get_team_events_cache_keys_and_controllers(team_keys, years) + \ cls._get_districtlist_cache_keys_and_controllers(years) + \ cls._get_district_events_cache_keys_and_controllers(event_district_abbrevs, years) + \ cls._get_district_rankings_cache_keys_and_controllers(event_district_abbrevs, years) + \ cls._queries_to_cache_keys_and_controllers(get_affected_queries.event_updated(affected_refs))
def event_updated(affected_refs): event_keys = _filter(affected_refs['key']) years = _filter(affected_refs['year']) event_district_keys = _filter(affected_refs['district_key']) event_team_keys_future = EventTeam.query(EventTeam.event.IN([event_key for event_key in event_keys])).fetch_async(None, keys_only=True) events_future = ndb.get_multi_async(event_keys) queries_and_keys = [] for event_key in event_keys: queries_and_keys.append((EventQuery(event_key.id()))) queries_and_keys.append(EventDivisionsQuery(event_key.id())) for year in years: queries_and_keys.append((EventListQuery(year))) for event_district_key in event_district_keys: queries_and_keys.append((DistrictEventsQuery(event_district_key.id()))) if event_keys: for et_key in event_team_keys_future.get_result(): team_key = et_key.id().split('_')[1] year = int(et_key.id()[:4]) queries_and_keys.append((TeamEventsQuery(team_key))) queries_and_keys.append((TeamYearEventsQuery(team_key, year))) queries_and_keys.append((TeamYearEventTeamsQuery(team_key, year))) events_with_parents = filter(lambda e: e.get_result() is not None and e.get_result().parent_event is not None, events_future) parent_keys = set([e.get_result().parent_event for e in events_with_parents]) for parent_key in parent_keys: queries_and_keys.append((EventDivisionsQuery(parent_key.id()))) return queries_and_keys
def get_teams_async(self): from models.event_team import EventTeam event_team_keys = yield EventTeam.query( EventTeam.event == self.key).fetch_async(500, keys_only=True) event_teams = yield ndb.get_multi_async(event_team_keys) team_keys = map(lambda event_team: event_team.team, event_teams) self._teams = yield ndb.get_multi_async(team_keys)
def get(self, year): year = int(year) team_districts = defaultdict(list) logging.info("Fetching events in {}".format(year)) year_events = Event.query( year == Event.year, Event.event_district_enum != DistrictType.NO_DISTRICT, Event.event_district_enum != None).fetch() for event in year_events: logging.info("Fetching EventTeams for {}".format(event.key_name)) event_teams = EventTeam.query(EventTeam.event == event.key).fetch() for event_team in event_teams: team_districts[event_team.team.id()].append( event.event_district_enum) new_district_teams = [] for team_key, districts in team_districts.iteritems(): most_frequent_district = max(set(districts), key=districts.count) logging.info("Assuming team {} belongs to {}".format( team_key, DistrictType.type_names[most_frequent_district])) dt_key = DistrictTeam.renderKeyName(year, most_frequent_district, team_key) new_district_teams.append( DistrictTeam(id=dt_key, year=year, team=ndb.Key(Team, team_key), district=most_frequent_district)) logging.info("Finishing updating old district teams from event teams") DistrictTeamManipulator.createOrUpdate(new_district_teams) self.response.out.write( "Finished creating district teams for {}".format(year))
def _query_async(self): team_key = self._query_args[0] event_teams = yield EventTeam.query( EventTeam.team == ndb.Key(Team, team_key)).fetch_async( keys_only=True) years = map(lambda event_team: int(event_team.id()[:4]), event_teams) raise ndb.Return(set(years))
def get_event_cache_keys_and_controllers(cls, affected_refs): """ Gets cache keys and controllers that references this event """ event_keys = affected_refs["key"] years = affected_refs["year"] event_district_abbrevs = affected_refs["event_district_abbrev"] event_team_keys_future = EventTeam.query( EventTeam.event.IN([event_key for event_key in event_keys]) ).fetch_async(None, keys_only=True) team_keys = set() for et_key in event_team_keys_future.get_result(): team_key_name = et_key.id().split("_")[1] team_keys.add(ndb.Key(Team, team_key_name)) return ( cls._get_events_cache_keys_and_controllers(event_keys) + cls._get_event_district_points_cache_keys_and_controllers(event_keys) + cls._get_eventlist_cache_keys_and_controllers(years) + cls._get_team_events_cache_keys_and_controllers(team_keys, years) + cls._get_districtlist_cache_keys_and_controllers(years) + cls._get_district_events_cache_keys_and_controllers(event_district_abbrevs, years) + cls._get_district_rankings_cache_keys_and_controllers(event_district_abbrevs, years) )
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): datafeed = DatafeedUsfirst() event = Event.get_by_id(event_key) new_awards = AwardManipulator.createOrUpdate(datafeed.getEventAwards(event)) if new_awards is None: new_awards = [] elif type(new_awards) != list: new_awards = [new_awards] # create EventTeams team_ids = set() for award in new_awards: for team in award.team_list: team_ids.add(team.id()) teams = TeamManipulator.createOrUpdate([Team( id=team_id, team_number=int(team_id[3:])) for team_id in team_ids]) if teams: if type(teams) is not list: teams = [teams] event_teams = EventTeamManipulator.createOrUpdate([EventTeam( id=event_key + "_" + team.key.id(), event=event.key, team=team.key, year=event.year) for team in teams]) template_values = { 'awards': new_awards, } path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_awards_get.html') self.response.out.write(template.render(path, template_values))
def get_event_details_cache_keys_and_controllers(cls, affected_refs): """ Gets cache keys and controllers that references this EventDetails TODO: Currently inefficient and also clears event APIv2 endpoints, since alliances are served under the event. APIv3 will break alliances out. """ event_details_keys = affected_refs['key'] event_keys = set() years = set() event_district_abbrevs = set() for event_details_key in event_details_keys: event_key = ndb.Key(Event, event_details_key.id()) event_keys.add(event_key) event = event_key.get() years.add(event.year) event_district_abbrevs.add(event.event_district_abbrev) event_team_keys_future = EventTeam.query(EventTeam.event.IN([event_key for event_key in event_keys])).fetch_async(None, keys_only=True) team_keys = set() for et_key in event_team_keys_future.get_result(): team_key_name = et_key.id().split('_')[1] team_keys.add(ndb.Key(Team, team_key_name)) return cls._get_events_cache_keys_and_controllers(event_keys) + \ cls._get_event_district_points_cache_keys_and_controllers(event_keys) + \ cls._get_eventlist_cache_keys_and_controllers(years) + \ cls._get_team_events_cache_keys_and_controllers(team_keys, years) + \ cls._get_districtlist_cache_keys_and_controllers(years) + \ cls._get_district_events_cache_keys_and_controllers(event_district_abbrevs, years) + \ cls._get_district_rankings_cache_keys_and_controllers(event_district_abbrevs, years) + \ cls._queries_to_cache_keys_and_controllers(get_affected_queries.event_details_updated(affected_refs))
def test_doEventTeamUpdate(self): # call EventTeamUpdate with 2010sc eventteamupdate = EventTeamUpdate() eventteamupdate.response = Response() eventteamupdate.get("2010sc") # Teams were generated by EventTeamUpdate, make sure EventTeams # exist and feature Team Keys event_team_from_match_one = EventTeam.get_by_id("2010sc_frc69") self.assertEqual(event_team_from_match_one.event, self.event.key) self.assertEqual(event_team_from_match_one.team, ndb.Key(Team, "frc69")) event_team_from_match_two = EventTeam.get_by_id("2010sc_frc20") self.assertEqual(event_team_from_match_two.event, self.event.key) self.assertEqual(event_team_from_match_two.team, ndb.Key(Team, "frc20"))
def _render(self, team_key): event_team_keys = EventTeam.query(EventTeam.team == ndb.Key(Team, team_key)).fetch(None, keys_only=True) years_participated = set() for event_team_key in event_team_keys: years_participated.add(int(event_team_key.id()[:4])) years_participated = sorted(list(years_participated)) return json.dumps(years_participated, ensure_ascii=True)
def prepTeams(self): # TODO there is a way to do this with yields such that this would be a # generator function that would yield, and if two sets of ndb fetches # went by would cleanly do itself without forcing a fetch. # -gregmarra 20121007 from models.event_team import EventTeam if self._teams_future is None: self._event_teams_future = EventTeam.query(EventTeam.event == self.key).fetch_async(500)
def setUp(self): app = webapp2.WSGIApplication([ webapp2.Route( r'/<event_key:>', ApiEventTeamsController, methods=['GET']) ], debug=True) self.testapp = webtest.TestApp(app) self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_urlfetch_stub() self.testbed.init_memcache_stub() self.testbed.init_taskqueue_stub() self.event = Event( id="2010sc", name="Palmetto Regional", event_type_enum=EventType.REGIONAL, short_name="Palmetto", event_short="sc", year=2010, end_date=datetime(2010, 03, 27), official=True, location='Clemson, SC', start_date=datetime(2010, 03, 24), ) self.event.put() self.team = Team( id="frc281", name="Michelin / Caterpillar / Greenville Technical College /\ jcpenney / Baldor / ASME / Gastroenterology Associates /\ Laserflex South & Greenville County Schools & Greenville\ Technical Charter High School", team_number=281, nickname="EnTech GreenVillians", address="Greenville, SC, USA", website="www.entech.org", ) self.team.put() self.event_team = EventTeam(team=self.team.key, event=self.event.key, year=datetime.now().year) self.event_team.put()
def _query_async(self): team_key = self._query_args[0] year = self._query_args[1] event_teams = yield EventTeam.query( EventTeam.team == ndb.Key(Team, team_key), EventTeam.year == year).fetch_async() event_keys = map(lambda event_team: event_team.event, event_teams) events = yield ndb.get_multi_async(event_keys) raise ndb.Return(events)
def getTeamData(self, event): #reader = csv.reader(open(file,"rb")) event_teams = EventTeam.query(EventTeam.event == event.key).fetch(500) team_keys = [event_team.team for event_team in event_teams] for num, team_key in enumerate(team_keys): OprHelper.teamdata.append([]) OprHelper.teamdata[num].append(num) # teamid OprHelper.teamdata[num].append(int(team_key[3:])) # teamnumber
def getAwards(self, event): awards = [] if event.event_type_enum == EventType.CMP_DIVISION and event.year >= 2015: # 8 subdivisions from 2015+ have awards listed under 4 divisions event_team_keys = EventTeam.query(EventTeam.event == event.key).fetch(keys_only=True) valid_team_nums = set([int(etk.id().split('_')[1][3:]) for etk in event_team_keys]) awards += self._parse(self.FMS_API_AWARDS_URL_PATTERN % (event.year, self._get_event_short(self.SUBDIV_TO_DIV[event.event_short])), FMSAPIAwardsParser(event, valid_team_nums)) awards += self._parse(self.FMS_API_AWARDS_URL_PATTERN % (event.year, self._get_event_short(event.event_short)), FMSAPIAwardsParser(event)) return awards
def get(self, event_key): self._require_admin() event = Event.get_by_id(event_key) if not event: self.abort(404) return existing_event_team_keys = set(EventTeam.query(EventTeam.event == event.key).fetch(1000, keys_only=True)) EventTeamManipulator.delete_keys(existing_event_team_keys) self.response.out.write("Deleted {} EventTeams from {}".format(len(existing_event_team_keys), event_key))
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, event_key): event = Event.get_by_id(event_key) event_teams = EventTeam.query(EventTeam.event==event.key).fetch() for event_team in event_teams: status = EventTeamStatusHelper.generate_team_at_event_status(event_team.team.id(), event) event_team.status = status FirebasePusher.update_event_team_status(event_key, event_team.team.id(), status) EventTeamManipulator.createOrUpdate(event_teams) if 'X-Appengine-Taskname' not in self.request.headers: # Only write out if not in taskqueue self.response.out.write("Finished calculating event team statuses for: {}".format(event_key))
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)