def get(self, first_eid):
df = DatafeedUsfirstEvents()
event = df.getEvent(first_eid)
event = EventUpdater.createOrUpdate(event)
teams = df.getEventRegistration(first_eid)
eventteams_count = 0
for team_dict in teams:
# This could be refactored to do a lot fewer DB requests by batching the Team and EventTeam gets.
# -gregmarra 5 Dec 2010
team = Team.get_by_key_name("frc" + str(team_dict["number"]))
if team is None:
team = Team(
team_number = int(team_dict["number"]),
first_tpid = int(team_dict["tpid"]),
key_name = "frc" + str(team_dict["number"])
)
team.put()
et = EventTeam.get_or_insert(
key_name = event.key().name() + "_" + team.key().name(),
event = event,
team = team)
eventteams_count = eventteams_count + 1
template_values = {
'event': event,
'eventteams_count': eventteams_count,
}
path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_event_get.html')
self.response.out.write(template.render(path, template_values))
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_key_name(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["event_keys"] = [a.event.key().name() for a in team.events]
team_dict["location"] = team.address
try:
team.do_split_address()
team_dict["location"] = team.split_address["full_address"]
team_dict["locality"] = team.split_address["locality"]
team_dict["region"] = team.split_address["region"]
team_dict["country"] = team.split_address["country"]
except Exception, e:
logging.error("Failed to include Address for api_team_info_%s" % team_key)
memcache.set(memcache_key, team_dict, 3600)
else:
return None
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_key_name(team_dict["key"])
for e in [a.event for a in team.events]:
match_list = e.match_set.filter("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.key().name()
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"] = simplejson.loads(match.alliances_json)
matches_list.append(match_dict)
memcache.set(memcache_key, matches_list, 600)
team_dict["matches"] = matches_list
return team_dict
def get(self, team_number):
team = Team.get_by_key_name("frc" + team_number)
template_values = {
'team' : team,
}
path = os.path.join(os.path.dirname(__file__), '../../templates/admin/teams/details.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_key_name = "frc%s" % q
team = Team.get_by_key_name(team_key_name)
if team:
self.redirect(team.details_url())
return None
except Exception, e:
logging.warning("warning: %s" % e)
def scrapeTpid(self, number, skip=0, year=2011):
"""
Searches the FIRST list of all teams for the requested team's tpid, caching
all it encounters in the datastore. This has the side effect of creating Team
objects along the way.
This code is taken directly from Pat Fairbank's frclinks source and modified
slightly to fit in the TBA framework. He has given us permission to borrow
his code directly.
"""
teams_to_put = list()
while 1:
logging.info("Fetching 250 teams based on %s data, skipping %s" % (year, skip))
# TODO: Make this robust to season changes. -gregmarra 9 Jan 2011
teamList = urlfetch.fetch(
'https://my.usfirst.org/myarea/index.lasso?page=searchresults&' +
'programs=FRC&reports=teams&sort_teams=number&results_size=250&' +
'omit_searchform=1&season_FRC=%s&skip_teams=%s' % (year, skip),
deadline=10)
teamResults = self.teamRe.findall(teamList.content)
tpid = None
for teamResult in teamResults:
teamNumber = self.teamNumberRe.findall(teamResult)[0]
teamTpid = self.tpidRe.findall(teamResult)[0]
if teamNumber == number:
tpid = teamTpid
logging.info("Team %s TPID was %s in year %s." % (teamNumber, teamTpid, year))
team = Team.get_by_key_name('frc' + str(teamNumber))
new_team = Team(
team_number = int(teamNumber),
first_tpid = int(teamTpid),
first_tpid_year = int(year),
key_name = "frc" + str(teamNumber)
)
if team is None:
teams_to_put.append(new_team)
else:
team = TeamUpdater.updateMerge(new_team, team)
teams_to_put.append(team)
skip = int(skip) + 250
db.put(teams_to_put)
teams_to_put = list()
if tpid:
return tpid
if len(self.lastPageRe.findall(teamList.content)) == 0:
return None
def get(self, key_name):
df = DatafeedUsfirstTeams()
old_team = Team.get_by_key_name(key_name)
logging.info("Updating team %s" % key_name)
new_team = df.getTeamDetails(old_team.team_number) #TODO old team can be null -gregmarra 21 mar 2011
team = TeamUpdater.createOrUpdate(new_team)
template_values = {
'team': team,
}
path = os.path.join(os.path.dirname(__file__), '../templates/team.html')
self.response.out.write(template.render(path, template_values))
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_key_name(team_dict["key"])
event_list = [self.getEventInfo(e.key().name()) for e in [a.event for a in team.events if a.year == int(year)]]
for event_dict in event_list:
event_dict["team_wlt"] = EventHelper.getTeamWLT(team_dict["key"], event_dict["key"])
memcache.set(memcache_key, event_list, 600)
team_dict["events"] = event_list
return team_dict
def get(self, team_number, year=None):
if type(year) == str:
year = int(year)
explicit_year = True
else:
year = datetime.datetime.now().year
explicit_year = False
memcache_key = "team_detail_%s_%s" % ("frc" + team_number, year)
html = memcache.get(memcache_key)
if html is None:
team = Team.get_by_key_name("frc" + team_number)
#todo better 404 handling
if not team:
self.redirect("/")
events = [a.event for a in team.events if a.year == year]
for event in events:
if not event.start_date:
event.start_date = datetime.datetime(year, 12, 31) #unknown goes last
events = sorted(events, key=lambda event: event.start_date)
years = sorted(set([a.year for a in team.events if a.year != None]))
participation = list()
# Return an array of event names and a list of matches from that event that the
# team was a participant in.
year_wlt_list = list()
for e in events:
match_list = e.match_set.filter("team_key_names =", team.key().name())
matches = MatchHelper.organizeMatches(match_list)
wlt = EventHelper.getTeamWLTFromMatches(team.key().name(), match_list)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
participation.append({ 'event' : e,
'matches' : matches,
'wlt': display_wlt })
team.do_split_address()
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
template_values = { "explicit_year": explicit_year,
"team": team,
"participation": participation,
"year": year,
"years": years,
"year_wlt": year_wlt }
path = os.path.join(os.path.dirname(__file__), '../templates/teams/details.html')
html = template.render(path, template_values)
memcache.set(memcache_key, html, 300)
self.response.out.write(html)
