def get(self, key_name): df = DatafeedUsfirst() legacy_df = DatafeedUsfirstLegacy() team = df.getTeamDetails(Team.get_by_id(key_name)) if not team: logging.warning("getTeamDetails with DatafeedUsfirst for event id {} failed. Retrying with DatafeedUsfirstLegacy.".format(key_name)) team = legacy_df.getTeamDetails(Team.get_by_id(key_name)) else: legacy_team = legacy_df.getTeamDetails(Team.get_by_id(key_name)) if legacy_team is not None: team.rookie_year = legacy_team.rookie_year # only available on legacy df if team: team = TeamManipulator.createOrUpdate(team) success = True else: success = False template_values = { 'key_name': key_name, 'team': team, 'success': success, } path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
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, key_name): # Combines data from three datafeeds with priorities: # 1) DatafeedFMSAPI # 2) DatafeedUsfirst (missing rookie year) # 3) DatafeedUsfirstLegacy (has all info) legacy_df = DatafeedUsfirstLegacy() usfirst_df = DatafeedUsfirst() fms_df = DatafeedFMSAPI('v2.0') # Start with lowest priority legacy_team = legacy_df.getTeamDetails(Team.get_by_id(key_name)) usfirst_team = usfirst_df.getTeamDetails(Team.get_by_id(key_name)) fms_details = fms_df.getTeamDetails(tba_config.MAX_YEAR, key_name) # Separate out the multiple models returned from FMSAPI call # Since we're only hitting one team at a time, the response won't # ever be paginated so we can ignore the possibility if fms_details and fms_details[0]: models, more_pages = fms_details fms_team, district_team, robot = models[0] else: fms_team = None district_team = None robot = None team = None if usfirst_team: team = TeamManipulator.updateMergeBase(usfirst_team, legacy_team) if fms_team: team = TeamManipulator.updateMergeBase(fms_team, team) if district_team: district_team = DistrictTeamManipulator.createOrUpdate( district_team) if robot: robot = RobotManipulator.createOrUpdate(robot) if team: team = TeamManipulator.createOrUpdate(team) success = True else: success = False logging.warning( "getTeamDetails failed for team: {}".format(key_name)) template_values = { 'key_name': key_name, 'team': team, 'success': success, 'district': district_team, 'robot': robot, } path = os.path.join( os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
def get(self, key_name): # Combines data from three datafeeds with priorities: # 1) DatafeedFMSAPI # 2) DatafeedUsfirst (missing rookie year) # 3) DatafeedUsfirstLegacy (has all info) legacy_df = DatafeedUsfirstLegacy() usfirst_df = DatafeedUsfirst() fms_df = DatafeedFMSAPI('v2.0') # Start with lowest priority legacy_team = legacy_df.getTeamDetails(Team.get_by_id(key_name)) usfirst_team = usfirst_df.getTeamDetails(Team.get_by_id(key_name)) fms_details = fms_df.getTeamDetails(tba_config.MAX_YEAR, key_name) # Separate out the multiple models returned from FMSAPI call # Since we're only hitting one team at a time, the response won't # ever be paginated so we can ignore the possibility if fms_details and fms_details[0]: models, more_pages = fms_details fms_team, district_team, robot = models[0] else: fms_team = None district_team = None robot = None team = None if usfirst_team: team = TeamManipulator.updateMergeBase(usfirst_team, legacy_team) if fms_team: team = TeamManipulator.updateMergeBase(fms_team, team) if district_team: district_team = DistrictTeamManipulator.createOrUpdate(district_team) if robot: robot = RobotManipulator.createOrUpdate(robot) if team: team = TeamManipulator.createOrUpdate(team) success = True else: success = False logging.warning("getTeamDetails failed for team: {}".format(key_name)) template_values = { 'key_name': key_name, 'team': team, 'success': success, 'district': district_team, 'robot': robot, } path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
def get(self, key_name): # Combines data from three datafeeds with priorities: # 1) DatafeedFMSAPI (missing website) # 2) DatafeedUsfirst (missing rookie year) # 3) DatafeedUsfirstLegacy (has all info) legacy_df = DatafeedUsfirstLegacy() usfirst_df = DatafeedUsfirst() fms_df = DatafeedFMSAPI('v2.0') # Start with lowest priority legacy_team = legacy_df.getTeamDetails(Team.get_by_id(key_name)) usfirst_team = usfirst_df.getTeamDetails(Team.get_by_id(key_name)) fms_details = fms_df.getTeamDetails(date.today().year, key_name) if fms_details: fms_team, district_team, robot = fms_details else: fms_team = None district_team = None robot = None team = None if usfirst_team: team = TeamManipulator.updateMergeBase(usfirst_team, legacy_team) if fms_team: team = TeamManipulator.updateMergeBase(fms_team, team) if district_team: district_team = DistrictTeamManipulator.createOrUpdate(district_team) if robot: robot = RobotManipulator.createOrUpdate(robot) if team: team = TeamManipulator.createOrUpdate(team) success = True else: success = False logging.warning("getTeamDetails failed for team: {}".format(key_name)) template_values = { 'key_name': key_name, 'team': team, 'success': success, 'district': district_team, 'robot': robot, } path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
def test_create_lots_of_teams(self): number = 500 teams = [ Team(id="frc%s" % team_number, team_number=team_number) for team_number in range(number) ] TeamManipulator.createOrUpdate(teams) team = Team.get_by_id("frc177") self.assertEqual(team.key_name, "frc177") self.assertEqual(team.team_number, 177) team = Team.get_by_id("frc%s" % (number - 1)) self.assertEqual(team.key_name, "frc%s" % (number - 1)) self.assertEqual(team.team_number, number - 1)
def test_create_lots_of_teams(self): number = 500 teams = [Team( id = "frc%s" % team_number, team_number = team_number) for team_number in range(number)] TeamManipulator.createOrUpdate(teams) team = Team.get_by_id("frc177") self.assertEqual(team.key_name, "frc177") self.assertEqual(team.team_number, 177) team = Team.get_by_id("frc%s" % (number - 1)) self.assertEqual(team.key_name, "frc%s" % (number - 1)) self.assertEqual(team.team_number, number - 1)
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, 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, 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 test_data_payload_team(self): team = Team.get_by_id('frc1') notification = AllianceSelectionNotification(self.event, team) payload = notification.data_payload self.assertEqual(len(payload), 2) self.assertEqual(payload['event_key'], self.event.key_name) self.assertEqual(payload['team_key'], team.key_name)
def get(self, key_name): team = Team.get_by_id(key_name) if team.website: WebsiteBlacklist.blacklist(team.website) self.redirect('/backend-tasks/get/team_details/{}'.format(key_name))
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 _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 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 alliance_selection(cls, event, user_id=None): from models.notifications.alliance_selection import AllianceSelectionNotification # Send to Event subscribers if NotificationType.ALLIANCE_SELECTION in NotificationType.enabled_event_notifications: users = [user_id] if user_id else [] if not users: users = Subscription.users_subscribed_to_event( event, NotificationType.ALLIANCE_SELECTION) if users: cls._send(users, AllianceSelectionNotification(event)) # Send to Team subscribers if NotificationType.ALLIANCE_SELECTION in NotificationType.enabled_team_notifications: for team_key in event.alliance_teams: try: team = Team.get_by_id(team_key) except: continue users = [user_id] if user_id else [] if not users: users = Subscription.users_subscribed_to_team( team, NotificationType.ALLIANCE_SELECTION) if users: cls._send(users, AllianceSelectionNotification(event, team))
def _getteam_rookieyear(cls, request): team_number = request['result']['parameters']['team_number'] team = Team.get_by_id('frc{}'.format(team_number)) if team: fmt = 'Team {0} first competed in {1}. Would you like to know more about {0} or another team?' text = fmt.format( team_number, team.rookie_year) tts = fmt.format( cls._team_number_tts(team_number), team.rookie_year) messages = cls._create_simple_response(text, tts=tts) + \ cls._create_suggestion_chips([ 'Next match', 'Current status', 'Location', 'Another team', 'No thanks', ]) else: fmt = 'Team {0} does not exist. Please ask about another team.' text = fmt.format(team_number) tts = fmt.format(cls._team_number_tts(team_number)) messages = cls._create_simple_response(text, tts=tts) return { 'speech': text, 'messages': messages, }
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 _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 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 _getteam_fallback(cls, request): team_number = None for context in request['result']['contexts']: if context['name'] == 'getteam': team_number = context['parameters']['team_number'] break team = Team.get_by_id('frc{}'.format(team_number)) if team: fmt = 'Sorry, I don\'t understand your question about Team {0}. Try asking about their next match, status, location, or rookie year.' else: fmt = 'Team {0} does not exist. Please ask about another team.' text = fmt.format(team_number) tts = fmt.format(cls._team_number_tts(team_number)) return { 'speech': text, 'messages': cls._create_simple_response(text, tts=tts) + cls._create_suggestion_chips([ 'Next match', 'Current status', 'Location', 'Rookie year', ]) }
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, 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 _getteam_rookieyear(cls, request): team_number = request['result']['parameters']['team_number'] team = Team.get_by_id('frc{}'.format(team_number)) if team: fmt = 'Team {0} first competed in {1}. Would you like to know more about {0} or another team?' text = fmt.format(team_number, team.rookie_year) tts = fmt.format(cls._team_number_tts(team_number), team.rookie_year) messages = cls._create_simple_response(text, tts=tts) + \ cls._create_suggestion_chips([ 'Next match', 'Current status', 'Location', 'Another team', 'No thanks', ]) else: fmt = 'Team {0} does not exist. Please ask about another team.' text = fmt.format(team_number) tts = fmt.format(cls._team_number_tts(team_number)) messages = cls._create_simple_response(text, tts=tts) return { 'speech': text, 'messages': messages, }
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 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 test_data_payload_team(self): team = Team.get_by_id('frc1') notification = MatchScoreNotification(self.match, team) payload = notification.data_payload self.assertEqual(len(payload), 3) self.assertEqual(payload['event_key'], '2020testpresent') self.assertEqual(payload['match_key'], '2020testpresent_qm1') self.assertEqual(payload['team_key'], 'frc1')
def get(self, team_key): team = Team.get_by_id(team_key) lat_lon = team.get_lat_lon() if lat_lon: fields = [ search.GeoField(name='location', value=search.GeoPoint(lat_lon[0], lat_lon[1])) ] search.Index(name="teamLocation").put(search.Document(doc_id=team.key.id(), fields=fields))
def test_data_payload_team(self): team = Team.get_by_id('frc1') notification = MatchScoreNotification(self.match, team) payload = notification.data_payload self.assertEqual(len(payload), 3) self.assertEqual(payload['event_key'], self.event.key_name) self.assertEqual(payload['match_key'], '{}_qm1'.format(self.event.key_name)) self.assertEqual(payload['team_key'], 'frc1')
def test_webhook_message_data_team(self): team = Team.get_by_id('frc1') notification = MatchScoreNotification(self.match, team) payload = notification.webhook_message_data self.assertEqual(len(payload), 4) self.assertEqual(payload['event_key'], self.event.key_name) self.assertEqual(payload['event_name'], 'Present Test Event') self.assertEqual(payload['team_key'], 'frc1') self.assertIsNotNone(payload['match'])
def _render(self, team_number, year): team = Team.get_by_id("frc{}".format(team_number)) if not team: self.abort(404) rendered_result = TeamRenderer.render_team_details(self, team, int(year), False) if rendered_result is None: self.abort(404) else: return rendered_result
def get(self, key_name): existing_team = Team.get_by_id(key_name) fms_df = DatafeedFMSAPI('v2.0') df2 = DatafeedFIRSTElasticSearch() year = datetime.date.today().year fms_details = fms_df.getTeamDetails(year, key_name) if fms_details: team, district_team, robot = fms_details[0] else: team = None district_team = None robot = None if team: team = TeamManipulator.mergeModels( team, df2.getTeamDetails(existing_team)) else: team = df2.getTeamDetails(existing_team) if team: team = TeamManipulator.createOrUpdate(team) # Clean up junk district teams # https://www.facebook.com/groups/moardata/permalink/1310068625680096/ dt_keys = DistrictTeam.query( DistrictTeam.team == existing_team.key, DistrictTeam.year == year).fetch(keys_only=True) keys_to_delete = set() for dt_key in dt_keys: if not district_team or dt_key.id() != district_team.key.id(): keys_to_delete.add(dt_key) DistrictTeamManipulator.delete_keys(keys_to_delete) if district_team: district_team = DistrictTeamManipulator.createOrUpdate( district_team) if robot: robot = RobotManipulator.createOrUpdate(robot) template_values = { 'key_name': key_name, 'team': team, 'success': team is not None, 'district': district_team, 'robot': robot, } if 'X-Appengine-Taskname' not in self.request.headers: # Only write out if not in taskqueue path = os.path.join( os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
def get(self): try: q = self.request.get("q") logging.info("search query: %s" % q) if q.isdigit(): team_id = "frc%s" % q team = Team.get_by_id(team_id) if team: self.redirect(team.details_url) return None except Exception, e: logging.warning("warning: %s" % e)
def _render(self, team_number): team = Team.get_by_id("frc{}".format(team_number)) if not team: self.abort(404) year = datetime.datetime.now().year rendered_result = TeamRenderer.render_team_details(self, team, year, True) if rendered_result is None: return TeamRenderer.render_team_history(self, team, True) else: return rendered_result
def post(self, award_key): event_key_name = self.request.get('event_key_name') award = Award( id = award_key, name = self.request.get('award_name'), event = Event.get_by_id(event_key_name).key, official_name = self.request.get('official_name'), team = Team.get_by_id(self.request.get('team_key')).key, awardee = self.request.get('awardee'), ) award = AwardManipulator.createOrUpdate(award) self.redirect("/admin/event/" + event_key_name)
def test_getTeamsTpids(self): Team( id="frc4409", team_number=4409, first_tpid=0, # should be 74735 first_tpid_year=2011).put() # We can skip 2000 records, paginate, and still get frc4409 and frc4410 in 2012 self.datafeed.getTeamsTpids(2012, skip=2000) # Check new team insertion frc4410 = Team.get_by_id("frc4410") self.assertEqual(frc4410.team_number, 4410) self.assertEqual(frc4410.first_tpid, 74193) self.assertEqual(frc4410.first_tpid_year, 2012) # Check old team updating frc4409 = Team.get_by_id("frc4409") self.assertEqual(frc4409.team_number, 4409) self.assertEqual(frc4409.first_tpid, 74735) self.assertEqual(frc4409.first_tpid_year, 2012)
def _getteam_status(cls, request): team_number = request['result']['parameters']['team_number'] team_key = 'frc{}'.format(team_number) team = Team.get_by_id(team_key) if team: events = TeamYearEventsQuery(team_key, datetime.datetime.now().year).fetch() current_event = None for event in events: if event.now: current_event = event if current_event: event_team = EventTeam.get_by_id('{}_{}'.format(current_event.key.id(), team_key)) text = EventTeamStatusHelper.generate_team_at_event_status_string( team_key, event_team.status, formatting=False, event=current_event) tts = 'Team {} {}'.format( cls._team_number_tts(team_number), EventTeamStatusHelper.generate_team_at_event_status_string( team_key, event_team.status, formatting=False, event=current_event, include_team=False, verbose=True)) additional_prompt = ' Would you like to know more about {} or another team?'.format(team_number) text += additional_prompt tts += additional_prompt messages = cls._create_simple_response(text, tts=tts) +\ cls._create_link_chip(current_event.display_name, 'https://www.thebluealliance.com/event/{}'.format(current_event.key.id())) else: fmt = 'Team {0} is not currently competing. Would you like to know more about {0} or another team?' text = fmt.format( team_number) tts = fmt.format( cls._team_number_tts(team_number)) messages = cls._create_simple_response(text, tts=tts) messages += cls._create_suggestion_chips([ 'Next match', 'Location', 'Rookie year', 'Another team', 'No thanks', ]) else: fmt = 'Team {0} does not exist. Please ask about another team.' text = fmt.format(team_number) tts = fmt.format(cls._team_number_tts(team_number)) messages = cls._create_simple_response(text, tts=tts) return { 'speech': text, 'messages': messages, }
def test_data_payload_team(self): self.notification.match.predicted_time = datetime( 2017, 11, 28, 13, 30, 59) self.notification.match.time = datetime(2017, 11, 28, 13, 00, 59) team = Team.get_by_id('frc1') self.notification.team = team payload = self.notification.data_payload self.assertEqual(len(payload), 3) self.assertEqual(payload['event_key'], self.event.key_name) self.assertEqual(payload['match_key'], self.match.key_name) self.assertEqual(payload['team_key'], team.key_name)
def test_getTeamsTpids(self): Team( id="frc4409", team_number=4409, first_tpid=0, # should be 74735 first_tpid_year=2011 ).put() # We can skip 2000 records, paginate, and still get frc4409 and frc4410 in 2012 self.datafeed.getTeamsTpids(2012, skip=2000) # Check new team insertion frc4410 = Team.get_by_id("frc4410") self.assertEqual(frc4410.team_number, 4410) self.assertEqual(frc4410.first_tpid, 74193) self.assertEqual(frc4410.first_tpid_year, 2012) # Check old team updating frc4409 = Team.get_by_id("frc4409") self.assertEqual(frc4409.team_number, 4409) self.assertEqual(frc4409.first_tpid, 74735) self.assertEqual(frc4409.first_tpid_year, 2012)
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) self.template_values.update({ 'event_teams': event_teams, 'team': team, }) 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, key_name): existing_team = Team.get_by_id(key_name) fms_df = DatafeedFMSAPI('v2.0') df2 = DatafeedFIRSTElasticSearch() year = datetime.date.today().year fms_details = fms_df.getTeamDetails(year, key_name) if fms_details: team, district_team, robot = fms_details[0] else: team = None district_team = None robot = None if team: team = TeamManipulator.mergeModels(team, df2.getTeamDetails(existing_team)) else: team = df2.getTeamDetails(existing_team) if team: team = TeamManipulator.createOrUpdate(team) # Clean up junk district teams # https://www.facebook.com/groups/moardata/permalink/1310068625680096/ dt_keys = DistrictTeam.query( DistrictTeam.team == existing_team.key, DistrictTeam.year == year).fetch(keys_only=True) keys_to_delete = set() for dt_key in dt_keys: if not district_team or dt_key.id() != district_team.key.id(): keys_to_delete.add(dt_key) DistrictTeamManipulator.delete_keys(keys_to_delete) if district_team: district_team = DistrictTeamManipulator.createOrUpdate(district_team) if robot: robot = RobotManipulator.createOrUpdate(robot) template_values = { 'key_name': key_name, 'team': team, 'success': team is not None, 'district': district_team, 'robot': robot, } if 'X-Appengine-Taskname' not in self.request.headers: # Only write out if not in taskqueue path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
def get(self, key_name): team_key = ndb.Key(Team, key_name) df = DatafeedUsfirst() first_eids = df.getPre2003TeamEvents(Team.get_by_id(key_name)) new_eids = [] for eid in first_eids: event_keys = Event.query(Event.first_eid == eid).fetch( 10, keys_only=True) if len(event_keys ) == 0: # only create events if event not already in db try: event = df.getEventDetails(eid) except: logging.warning( "getEventDetails for eid {} failed.".format(eid)) continue if event.event_type_enum in { EventType.CMP_DIVISION, EventType.CMP_FINALS }: if event.year >= 2001: # Divisions started in 2001; need to manually create championship events continue else: # No divisions; force event type to be finals event.event_type_enum = EventType.CMP_FINALS event = EventManipulator.createOrUpdate(event) new_eids.append(eid) else: event = event_keys[0].get() event_team_key_name = event.key.id() + "_" + team_key.id() existing_event_team = ndb.Key(EventTeam, event_team_key_name).get() if existing_event_team is None: event_team = EventTeam(id=event_team_key_name, event=event.key, team=team_key, year=event.year) EventTeamManipulator.createOrUpdate(event_team) template_values = {'first_eids': first_eids, 'new_eids': new_eids} path = os.path.join( os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_events_get.html') self.response.out.write(template.render(path, template_values))
def test_webhook_message_data_team(self): self.notification.match.time = None self.notification.match.predicted_time = None self.notification.event._webcast = [] team = Team.get_by_id('frc1') self.notification.team = team payload = self.notification.webhook_message_data self.assertEqual(len(payload), 5) self.assertEqual(payload['event_key'], self.event.key_name) self.assertEqual(payload['match_key'], self.match.key_name) self.assertEqual(payload['team_key'], team.key_name) self.assertEqual(payload['event_name'], 'Present Test Event') self.assertIsNotNone(payload['team_keys'])
def get(self, key_name): df = DatafeedUsfirst() team = df.getTeamDetails(Team.get_by_id(key_name)) if team: team = TeamManipulator.createOrUpdate(team) success = True else: success = False template_values = { 'team': team, 'success': success, } path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_details_get.html') self.response.out.write(template.render(path, template_values))
def post(self): team_number = self.request.get("team_number") if not team_number: self.abort(400) team_number = int(team_number) team = Team.get_by_id("frc{}".format(team_number)) if not team: self.abort(400) self._require_team_admin_access(team_number) action = self.request.get('action') if action == "remove_media_reference": media, team_ref = self.get_media_and_team_ref(team_number) if team_ref in media.references: media.references.remove(team_ref) if team_ref in media.preferred_references: media.preferred_references.remove(team_ref) MediaManipulator.createOrUpdate(media, auto_union=False) elif action == "remove_media_preferred": media, team_ref = self.get_media_and_team_ref(team_number) if team_ref in media.preferred_references: media.preferred_references.remove(team_ref) MediaManipulator.createOrUpdate(media, auto_union=False) elif action == "add_media_preferred": media, team_ref = self.get_media_and_team_ref(team_number) if team_ref not in media.preferred_references: media.preferred_references.append(team_ref) MediaManipulator.createOrUpdate(media, auto_union=False) elif action == "set_team_info": robot_name = self.request.get("robot_name").strip() current_year = datetime.datetime.now().year robot_key = Robot.renderKeyName(team.key_name, current_year) if robot_name: robot = Robot( id=robot_key, team=team.key, year=current_year, robot_name=robot_name, ) RobotManipulator.createOrUpdate(robot) else: RobotManipulator.delete_keys([ndb.Key(Robot, robot_key)]) else: self.abort(400) self.redirect('/mod/')
def get(self, key_name): team_key = ndb.Key(Team, key_name) df = DatafeedUsfirst() first_eids = df.getPre2003TeamEvents(Team.get_by_id(key_name)) new_eids = [] for eid in first_eids: event_keys = Event.query(Event.first_eid == eid).fetch(10, keys_only=True) if len(event_keys) == 0: # only create events if event not already in db try: event = df.getEventDetails(eid) except: logging.warning("getEventDetails for eid {} failed.".format(eid)) continue if event.event_type_enum in {EventType.CMP_DIVISION, EventType.CMP_FINALS}: if event.year >= 2001: # Divisions started in 2001; need to manually create championship events continue else: # No divisions; force event type to be finals event.event_type_enum = EventType.CMP_FINALS event = EventManipulator.createOrUpdate(event) new_eids.append(eid) else: event = event_keys[0].get() event_team_key_name = event.key.id() + "_" + team_key.id() existing_event_team = ndb.Key(EventTeam, event_team_key_name).get() if existing_event_team is None: event_team = EventTeam( id=event_team_key_name, event=event.key, team=team_key, year=event.year) EventTeamManipulator.createOrUpdate(event_team) template_values = {'first_eids': first_eids, 'new_eids': new_eids} path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_team_events_get.html') self.response.out.write(template.render(path, template_values))
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 _process_request(self, request, event_key): team_keys = JSONTeamListParser.parse(request.body) 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=self.event.key.id() + '_{}'.format(team_key), event=self.event.key, team=ndb.Key(Team, team_key), year=self.event.year)) # delete old eventteams old_eventteam_keys = EventTeam.query(EventTeam.event == self.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 get(self): try: q = self.request.get("q") logging.info("search query: %s" % q) if q.isdigit(): team_id = "frc%s" % q team = Team.get_by_id(team_id) if team: self.redirect(team.details_url) return None elif len(q) in {3, 4, 5}: # event shorts are between 3 and 5 characters long year = datetime.datetime.now().year # default to current year event_id = "%s%s" % (year, q) event = Event.get_by_id(event_id) if event: self.redirect(event.details_url) return None except Exception, e: logging.warning("warning: %s" % e)
def validate_team(team_number): """ Returns: Team object if the team exists and is currently competing String with the appropriate error otherwise """ team_key = 'frc{}'.format(team_number) team = Team.get_by_id(team_key) if not team: return "Team {} does not exist.".format(team_number) team_events_future = TeamEventsQuery(team_key).fetch_async() current_event = None for event in team_events_future.get_result(): if event.now: current_event = event if not current_event: return "Team {} is not currently competing.".format(team_number) return team, current_event
def addTeamEvents(self, 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 = [self.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) team_medias_by_year = {} for media in team_medias: if media.year in team_medias_by_year: team_medias_by_year[media.year].append(media) else: team_medias_by_year[media.year] = [media] self.template_values.update( {"event_teams": event_teams, "team": team, "team_medias_by_year": team_medias_by_year} ) path = os.path.join(os.path.dirname(__file__), "../../templates/admin/team_details.html") self.response.out.write(template.render(path, self.template_values))