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