def _process_request(self, request, event_key):
event = Event.get_by_id(event_key)
awards = []
for award in JSONAwardsParser.parse(request.body, event_key):
awards.append(
Award(id=Award.render_key_name(event.key_name,
award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[
ndb.Key(Team, team_key)
for team_key in award['team_key_list']
],
recipient_json_list=award['recipient_json_list']))
# it's easier to clear all awards and add new ones than try to find the difference
old_award_keys = Award.query(Award.event == event.key).fetch(
None, keys_only=True)
AwardManipulator.delete_keys(old_award_keys)
if event.remap_teams:
EventHelper.remapteams_awards(awards, event.remap_teams)
AwardManipulator.createOrUpdate(awards)
self.response.out.write(
json.dumps({'Success': "Awards successfully updated"}))
def get(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
if not event.remap_teams:
return
event.prepAwardsMatchesTeams()
# Remap matches
EventHelper.remapteams_matches(event.matches, event.remap_teams)
MatchManipulator.createOrUpdate(event.matches)
# Remap alliance selections
if event.alliance_selections:
EventHelper.remapteams_alliances(event.alliance_selections, event.remap_teams)
# Remap rankings
if event.rankings:
EventHelper.remapteams_rankings(event.rankings, event.remap_teams)
if event.details and event.details.rankings2:
EventHelper.remapteams_rankings2(event.details.rankings2, event.remap_teams)
EventDetailsManipulator.createOrUpdate(event.details)
# Remap awards
EventHelper.remapteams_awards(event.awards, event.remap_teams)
AwardManipulator.createOrUpdate(event.awards, auto_union=False)
def _process_request(self, request, event_key):
event = Event.get_by_id(event_key)
awards = []
for award in JSONAwardsParser.parse(request.body, event_key):
awards.append(Award(
id=Award.render_key_name(event.key_name, award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, team_key) for team_key in award['team_key_list']],
recipient_json_list=award['recipient_json_list']
))
# it's easier to clear all awards and add new ones than try to find the difference
old_award_keys = Award.query(Award.event == event.key).fetch(None, keys_only=True)
AwardManipulator.delete_keys(old_award_keys)
if event.remap_teams:
EventHelper.remapteams_awards(awards, event.remap_teams)
AwardManipulator.createOrUpdate(awards)
self.response.out.write(json.dumps({'Success': "Awards successfully updated"}))
def post(self):
event_key = self.request.get('event_key')
awards_json = self.request.get('awards_json')
awards = json.loads(awards_json)
event = Event.get_by_id(event_key)
def _getTeamKey(award):
team = Team.get_by_id('frc' + str(award.get('team_number', None)))
if team is not None:
return team.key
else:
return None
awards = [Award(
id = Award.renderKeyName(event.key_name, award.get('name')),
name = award.get('name', None),
team = _getTeamKey(award),
awardee = award.get('awardee', None),
year = event.year,
official_name = award.get('official_name', None),
event = event.key)
for award in awards]
AwardManipulator.createOrUpdate(awards)
self.redirect('/admin/event/{}'.format(event_key))
def get(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
if not event.remap_teams:
return
event.prepAwardsMatchesTeams()
# Remap matches
EventHelper.remapteams_matches(event.matches, event.remap_teams)
MatchManipulator.createOrUpdate(event.matches)
# Remap alliance selections
if event.alliance_selections:
EventHelper.remapteams_alliances(event.alliance_selections, event.remap_teams)
# Remap rankings
if event.rankings:
EventHelper.remapteams_rankings(event.rankings, event.remap_teams)
if event.details and event.details.rankings2:
EventHelper.remapteams_rankings2(event.details.rankings2, event.remap_teams)
EventDetailsManipulator.createOrUpdate(event.details)
# Remap awards
EventHelper.remapteams_awards(event.awards, event.remap_teams)
AwardManipulator.createOrUpdate(event.awards, auto_union=False)
def post(self):
award_key = self.request.get('award_key')
if not award_key:
self.abort(400)
award = Award.get_by_id(award_key)
if not award:
self.abort(404)
AwardManipulator.delete(award)
self.redirect('/admin/awards')
def post(self):
award_key = self.request.get('award_key')
if not award_key:
self.abort(400)
award = Award.get_by_id(award_key)
if not award:
self.abort(404)
AwardManipulator.delete(award)
self.redirect('/admin/awards')
def get(self, event_key):
datafeed = DatafeedUsfirst()
event = Event.get_by_id(event_key)
new_awards = AwardManipulator.createOrUpdate(datafeed.getEventAwards(event))
if new_awards is None:
new_awards = []
elif type(new_awards) != list:
new_awards = [new_awards]
# create EventTeams
team_ids = set()
for award in new_awards:
for team in award.team_list:
team_ids.add(team.id())
teams = TeamManipulator.createOrUpdate([Team(
id=team_id,
team_number=int(team_id[3:]))
for team_id in team_ids])
if teams:
if type(teams) is not list:
teams = [teams]
event_teams = EventTeamManipulator.createOrUpdate([EventTeam(
id=event_key + "_" + team.key.id(),
event=event.key,
team=team.key,
year=event.year)
for team in teams])
template_values = {
'awards': new_awards,
}
path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_awards_get.html')
self.response.out.write(template.render(path, template_values))
def get(self, event_key):
datafeed = DatafeedUsfirst()
event = Event.get_by_id(event_key)
new_awards = AwardManipulator.createOrUpdate(datafeed.getEventAwards(event))
if type(new_awards) != list:
new_awards = [new_awards]
# create EventTeams
team_ids = set()
for award in new_awards:
for team in award.team_list:
team_ids.add(team.id())
teams = TeamManipulator.createOrUpdate([Team(
id=team_id,
team_number=int(team_id[3:]))
for team_id in team_ids])
if teams:
event_teams = EventTeamManipulator.createOrUpdate([EventTeam(
id=event_key + "_" + team.key.id(),
event=event.key,
team=team.key,
year=event.year)
for team in teams])
template_values = {
'awards': new_awards,
}
path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_awards_get.html')
self.response.out.write(template.render(path, template_values))
def add_awards_from_csv(cls, awards_csv):
events = {} # for reducing datastore fetches of events and teams
awards = []
for award in CSVAwardsParser.parse(awards_csv):
event_key_name = '{}{}'.format(award['year'], award['event_short'])
if event_key_name in events:
event = events[event_key_name]
else:
event = Event.get_by_id(event_key_name)
if event is None:
logging.warning("Event: {} doesn't exist!".format(event_key_name))
continue
events[event_key_name] = event
awards.append(Award(
id=Award.render_key_name(event.key_name, award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team_number)) for team_number in award['team_number_list']],
recipient_json_list=award['recipient_json_list']
))
new_awards = AwardManipulator.createOrUpdate(awards)
if type(new_awards) != list:
new_awards = [new_awards]
return new_awards
def add_awards_from_csv(cls, awards_csv):
events = {} # for reducing datastore fetches of events and teams
awards = []
for award in CSVAwardsParser.parse(awards_csv):
event_key_name = '{}{}'.format(award['year'], award['event_short'])
if event_key_name in events:
event = events[event_key_name]
else:
event = Event.get_by_id(event_key_name)
if event is None:
logging.warning(
"Event: {} doesn't exist!".format(event_key_name))
continue
events[event_key_name] = event
awards.append(
Award(id=Award.render_key_name(event.key_name,
award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[
ndb.Key(Team, 'frc{}'.format(team_number))
for team_number in award['team_number_list']
],
recipient_json_list=award['recipient_json_list']))
new_awards = AwardManipulator.createOrUpdate(awards)
if type(new_awards) != list:
new_awards = [new_awards]
return new_awards
def get(self, event_key):
# Fetch for later
event_future = Event.get_by_id_async(event_key)
matches_future = match_query.EventMatchesQuery(event_key).fetch_async()
# Rebuild event teams
taskqueue.add(
url='/tasks/math/do/eventteam_update/' + event_key,
method='GET')
# Create Winner/Finalist awards for offseason events
awards = []
event = event_future.get_result()
if event.event_type_enum in {EventType.OFFSEASON, EventType.FOC}:
matches = MatchHelper.organizeMatches(matches_future.get_result())
bracket = MatchHelper.generateBracket(matches, event, event.alliance_selections)
if 'f' in bracket:
winning_alliance = '{}_alliance'.format(bracket['f'][1]['winning_alliance'])
if winning_alliance == 'red_alliance':
losing_alliance = 'blue_alliance'
else:
losing_alliance = 'red_alliance'
awards.append(Award(
id=Award.render_key_name(event.key_name, AwardType.WINNER),
name_str="Winner",
award_type_enum=AwardType.WINNER,
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team)) for team in bracket['f'][1][winning_alliance] if team.isdigit()],
recipient_json_list=[json.dumps({'team_number': team, 'awardee': None}) for team in bracket['f'][1][winning_alliance]],
))
awards.append(Award(
id=Award.render_key_name(event.key_name, AwardType.FINALIST),
name_str="Finalist",
award_type_enum=AwardType.FINALIST,
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team)) for team in bracket['f'][1][losing_alliance] if team.isdigit()],
recipient_json_list=[json.dumps({'team_number': team, 'awardee': None}) for team in bracket['f'][1][losing_alliance]],
))
AwardManipulator.createOrUpdate(awards)
self.response.out.write("Finished post-event tasks for {}. Created awards: {}".format(event_key, awards))
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 get(self, event_key):
datafeed = DatafeedUsfirst()
event = Event.get_by_id(event_key)
new_awards = AwardManipulator.createOrUpdate(datafeed.getEventAwards(event))
template_values = {
'awards': new_awards,
}
path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_awards_get.html')
self.response.out.write(template.render(path, template_values))
def get(self, event_key):
datafeed = DatafeedFMSAPI('v2.0', save_response=True)
event = Event.get_by_id(event_key)
awards = datafeed.getAwards(event)
if event and event.remap_teams:
EventHelper.remapteams_awards(awards, event.remap_teams)
new_awards = AwardManipulator.createOrUpdate(awards)
if new_awards is None:
new_awards = []
elif type(new_awards) != list:
new_awards = [new_awards]
# create EventTeams
team_ids = set()
for award in new_awards:
for team in award.team_list:
team_ids.add(team.id())
teams = TeamManipulator.createOrUpdate([
Team(id=team_id, team_number=int(team_id[3:]))
for team_id in team_ids
])
if teams:
if type(teams) is not list:
teams = [teams]
event_teams = EventTeamManipulator.createOrUpdate([
EventTeam(id=event_key + "_" + team.key.id(),
event=event.key,
team=team.key,
year=event.year) for team in teams
])
template_values = {
'awards': new_awards,
}
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_awards_get.html')
self.response.out.write(template.render(path, template_values))
def store_award(data, event):
award = Award(id=Award.render_key_name(data['event_key'], data['award_type']))
award.event = ndb.Key(Event, data['event_key'])
award.award_type_enum = data['award_type']
award.year = data['year']
award.name_str = data['name']
award.event_type_enum = event.event_type_enum
recipient_list_fixed = []
team_keys = []
for recipient in data['recipient_list']:
if recipient['team_key']:
team_keys.append(ndb.Key(Team, recipient['team_key']))
recipient_list_fixed.append(json.dumps({
'awardee': recipient['awardee'],
'team_number': int(recipient['team_key'][3:]) if recipient['team_key'] else None,
}))
award.recipient_json_list = recipient_list_fixed
return AwardManipulator.createOrUpdate(award)
def store_award(data, event):
award = Award(id=Award.render_key_name(data['event_key'], data['award_type']))
award.event = ndb.Key(Event, data['event_key'])
award.award_type_enum = data['award_type']
award.year = data['year']
award.name_str = data['name']
award.event_type_enum = event.event_type_enum
recipient_list_fixed = []
team_keys = []
for recipient in data['recipient_list']:
if recipient['team_key']:
team_keys.append(ndb.Key(Team, recipient['team_key']))
recipient_list_fixed.append(json.dumps({
'awardee': recipient['awardee'],
'team_number': int(recipient['team_key'][3:]) if recipient['team_key'] else None,
}))
award.recipient_json_list = recipient_list_fixed
return AwardManipulator.createOrUpdate(award)
def get(self, event_key):
datafeed = DatafeedFMSAPI('v2.0', save_response=True)
event = Event.get_by_id(event_key)
awards = datafeed.getAwards(event)
if event and event.remap_teams:
EventHelper.remapteams_awards(awards, event.remap_teams)
new_awards = AwardManipulator.createOrUpdate(awards)
if new_awards is None:
new_awards = []
elif type(new_awards) != list:
new_awards = [new_awards]
# create EventTeams
team_ids = set()
for award in new_awards:
for team in award.team_list:
team_ids.add(team.id())
teams = TeamManipulator.createOrUpdate([Team(
id=team_id,
team_number=int(team_id[3:]))
for team_id in team_ids])
if teams:
if type(teams) is not list:
teams = [teams]
event_teams = EventTeamManipulator.createOrUpdate([EventTeam(
id=event_key + "_" + team.key.id(),
event=event.key,
team=team.key,
year=event.year)
for team in teams])
template_values = {
'awards': new_awards,
}
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_awards_get.html')
self.response.out.write(template.render(path, template_values))
def post(self):
self._require_admin()
awards_csv = self.request.get('awards_csv')
events = {} # for reducing datastore fetches of events and teams
awards = []
for award in CSVAwardsParser.parse(awards_csv):
event_key_name = '{}{}'.format(award['year'], award['event_short'])
if event_key_name in events:
event = events[event_key_name]
else:
event = Event.get_by_id(event_key_name)
if event is None:
logging.warning(
"Event: {} doesn't exist!".format(event_key_name))
continue
events[event_key_name] = event
awards.append(
Award(id=Award.render_key_name(event.key_name,
award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[
ndb.Key(Team, 'frc{}'.format(team_number))
for team_number in award['team_number_list']
],
recipient_json_list=award['recipient_json_list']))
new_awards = AwardManipulator.createOrUpdate(awards)
if type(new_awards) != list:
new_awards = [new_awards]
self.template_values = {
'awards': new_awards,
}
path = os.path.join(os.path.dirname(__file__),
'../../templates/admin/awards_add.html')
self.response.out.write(template.render(path, self.template_values))
def post(self, award_key):
self._require_admin()
event_key_name = self.request.get('event_key_name')
recipient_json_list = []
team_list = []
for recipient in json.loads(self.request.get('recipient_list_json')):
recipient_json_list.append(json.dumps(recipient))
if recipient['team_number'] is not None:
team_list.append(ndb.Key(Team, 'frc{}'.format(recipient['team_number'])))
award = Award(
id=award_key,
name_str=self.request.get('name_str'),
award_type_enum=int(self.request.get('award_type_enum')),
event=ndb.Key(Event, event_key_name),
event_type_enum=int(self.request.get('event_type_enum')),
team_list=team_list,
recipient_json_list=recipient_json_list,
)
award = AwardManipulator.createOrUpdate(award, auto_union=False)
self.redirect("/admin/event/" + event_key_name)
def post(self):
self._require_admin()
awards_csv = self.request.get('awards_csv')
events = {} # for reducing datastore fetches of events and teams
awards = []
for award in CSVAwardsParser.parse(awards_csv):
event_key_name = '{}{}'.format(award['year'], award['event_short'])
if event_key_name in events:
event = events[event_key_name]
else:
event = Event.get_by_id(event_key_name)
if event is None:
logging.warning("Event: {} doesn't exist!".format(event_key_name))
continue
events[event_key_name] = event
awards.append(Award(
id=Award.render_key_name(event.key_name, award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team_number)) for team_number in award['team_number_list']],
recipient_json_list=award['recipient_json_list']
))
new_awards = AwardManipulator.createOrUpdate(awards)
if type(new_awards) != list:
new_awards = [new_awards]
self.template_values = {
'awards': new_awards,
}
path = os.path.join(os.path.dirname(__file__), '../../templates/admin/awards_add.html')
self.response.out.write(template.render(path, self.template_values))
def post(self, award_key):
self._require_admin()
event_key_name = self.request.get('event_key_name')
recipient_json_list = []
team_list = []
for recipient in json.loads(self.request.get('recipient_list_json')):
recipient_json_list.append(json.dumps(recipient))
if recipient['team_number'] is not None:
team_list.append(
ndb.Key(Team, 'frc{}'.format(recipient['team_number'])))
award = Award(
id=award_key,
name_str=self.request.get('name_str'),
award_type_enum=int(self.request.get('award_type_enum')),
event=ndb.Key(Event, event_key_name),
event_type_enum=int(self.request.get('event_type_enum')),
team_list=team_list,
recipient_json_list=recipient_json_list,
)
award = AwardManipulator.createOrUpdate(award, auto_union=False)
self.redirect("/admin/event/" + event_key_name)
def testApiCacheClear(self):
self.assertEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll(flushed=True)
# this shouldn't evict any caches
EventManipulator.createOrUpdate(self.event_2010sc_1)
EventTeamManipulator.createOrUpdate(self.eventteam_2010sc_frc1)
EventTeamManipulator.createOrUpdate(self.eventteam_2010sc_frc2)
AwardManipulator.createOrUpdate(self.award1_1)
MatchManipulator.createOrUpdate(self.match1_1)
TeamManipulator.createOrUpdate(self.team_frc1_1)
TeamManipulator.createOrUpdate(self.team_frc2_1)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc2_cache_key), None)
# updating an event
EventManipulator.createOrUpdate(self.event_2010sc_2)
self.assertEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# updating a team
TeamManipulator.createOrUpdate(self.team_frc1_2)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# updating a match
MatchManipulator.createOrUpdate(self.match1_2)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# updating an award
AwardManipulator.createOrUpdate(self.award1_2)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# deleting an award
AwardManipulator.delete(self.award1_2)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# deleting a match
MatchManipulator.delete(self.match1_2)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# deleting a team
TeamManipulator.delete(self.team_frc2_2)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# deleting an event
EventManipulator.delete(self.event_2010sc_2)
self.assertEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
self.resetAll()
# deleting an eventteam
EventTeamManipulator.delete(self.eventteam_2010sc_frc1)
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc2_cache_key), None)
def test_findOrSpawn_no_auto_union(self):
self.old_award.put()
self.assertMergedAward(
AwardManipulator.findOrSpawn(self.new_award, auto_union=False),
False)
def test_updateMerge_no_auto_union(self):
self.assertMergedAward(AwardManipulator.updateMerge(self.new_award, self.old_award, auto_union=False), False)
def test_findOrSpawn_no_auto_union(self):
self.old_award.put()
self.assertMergedAward(AwardManipulator.findOrSpawn(self.new_award, auto_union=False), False)
def test_findOrSpawn(self):
self.old_award.put()
self.assertMergedAward(AwardManipulator.findOrSpawn(self.new_award), True)
def test_createOrUpdate(self):
AwardManipulator.createOrUpdate(self.old_award)
self.assertOldAward(Award.get_by_id("2013casj_1"))
AwardManipulator.createOrUpdate(self.new_award)
self.assertMergedAward(Award.get_by_id("2013casj_1"), True)
def test_createOrUpdate_no_auto_union(self):
AwardManipulator.createOrUpdate(self.old_award)
self.assertOldAward(Award.get_by_id("2013casj_1"))
AwardManipulator.createOrUpdate(self.new_award, auto_union=False)
self.assertMergedAward(Award.get_by_id("2013casj_1"), False)
def test_updateMerge(self):
self.assertMergedAward(AwardManipulator.updateMerge(self.new_award, self.old_award), True)
def test_createOrUpdate(self):
AwardManipulator.createOrUpdate(self.old_award)
self.assertOldAward(Award.get_by_id("2013casj_1"))
AwardManipulator.createOrUpdate(self.new_award)
self.assertMergedAward(Award.get_by_id("2013casj_1"), True)
def get(self, event_key):
if tba_config.CONFIG["env"] == "prod": # disable in prod for now
logging.error("Tried to restore {} from CSV in prod! No can do.".format(event_key))
return
event = Event.get_by_id(event_key)
# alliances
result = urlfetch.fetch(self.ALLIANCES_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.ALLIANCES_URL.format(event.year, event_key, event_key)))
else:
data = result.content.replace('frc', '')
alliance_selections = CSVAllianceSelectionsParser.parse(data)
event_details = EventDetails(
id=event_key,
alliance_selections=alliance_selections
)
EventDetailsManipulator.createOrUpdate(event_details)
# awards
result = urlfetch.fetch(self.AWARDS_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.AWARDS_URL.format(event.year, event_key, event_key)))
else:
# convert into expected input format
data = StringIO.StringIO()
writer = csv.writer(data, delimiter=',')
for row in csv.reader(StringIO.StringIO(result.content), delimiter=','):
writer.writerow([event.year, event.event_short, row[1], row[2].replace('frc', ''), row[3]])
awards = []
for award in CSVAwardsParser.parse(data.getvalue()):
awards.append(Award(
id=Award.render_key_name(event.key_name, award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team_number)) for team_number in award['team_number_list']],
recipient_json_list=award['recipient_json_list']
))
AwardManipulator.createOrUpdate(awards)
# matches
result = urlfetch.fetch(self.MATCHES_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.MATCHES_URL.format(event.year, event_key, event_key)))
else:
data = result.content.replace('frc', '').replace('{}_'.format(event_key), '')
match_dicts, _ = OffseasonMatchesParser.parse(data)
matches = [
Match(
id=Match.renderKeyName(
event.key.id(),
match.get("comp_level", None),
match.get("set_number", 0),
match.get("match_number", 0)),
event=event.key,
year=event.year,
set_number=match.get("set_number", 0),
match_number=match.get("match_number", 0),
comp_level=match.get("comp_level", None),
team_key_names=match.get("team_key_names", None),
alliances_json=match.get("alliances_json", None)
)
for match in match_dicts]
MatchManipulator.createOrUpdate(matches)
# rankings
result = urlfetch.fetch(self.RANKINGS_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.RANKINGS_URL.format(event.year, event_key, event_key)))
else:
# convert into expected input format
rankings = list(csv.reader(StringIO.StringIO(result.content), delimiter=','))
event_details = EventDetails(
id=event_key,
rankings=rankings
)
EventDetailsManipulator.createOrUpdate(event_details)
self.response.out.write("Done restoring {}!".format(event_key))
def test_createOrUpdate_no_auto_union(self):
AwardManipulator.createOrUpdate(self.old_award)
self.assertOldAward(Award.get_by_id("2013casj_1"))
AwardManipulator.createOrUpdate(self.new_award, auto_union=False)
self.assertMergedAward(Award.get_by_id("2013casj_1"), False)
def test_updateMerge(self):
self.assertMergedAward(
AwardManipulator.updateMerge(self.new_award, self.old_award), True)
def test_findOrSpawn(self):
self.old_award.put()
self.assertMergedAward(AwardManipulator.findOrSpawn(self.new_award),
True)
def get(self, event_key):
if tba_config.CONFIG["env"] == "prod": # disable in prod for now
logging.error("Tried to restore {} from CSV in prod! No can do.".format(event_key))
return
event = Event.get_by_id(event_key)
# alliances
result = urlfetch.fetch(self.ALLIANCES_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.ALLIANCES_URL.format(event.year, event_key, event_key)))
else:
data = result.content.replace('frc', '')
alliance_selections = CSVAllianceSelectionsParser.parse(data)
event_details = EventDetails(
id=event_key,
alliance_selections=alliance_selections
)
EventDetailsManipulator.createOrUpdate(event_details)
# awards
result = urlfetch.fetch(self.AWARDS_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.AWARDS_URL.format(event.year, event_key, event_key)))
else:
# convert into expected input format
data = StringIO.StringIO()
writer = csv.writer(data, delimiter=',')
for row in csv.reader(StringIO.StringIO(result.content), delimiter=','):
writer.writerow([event.year, event.event_short, row[1], row[2].replace('frc', ''), row[3]])
awards = []
for award in CSVAwardsParser.parse(data.getvalue()):
awards.append(Award(
id=Award.render_key_name(event.key_name, award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=event.year,
event=event.key,
event_type_enum=event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team_number)) for team_number in award['team_number_list']],
recipient_json_list=award['recipient_json_list']
))
AwardManipulator.createOrUpdate(awards)
# matches
result = urlfetch.fetch(self.MATCHES_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.MATCHES_URL.format(event.year, event_key, event_key)))
else:
data = result.content.replace('frc', '').replace('{}_'.format(event_key), '')
match_dicts, _ = OffseasonMatchesParser.parse(data)
matches = [
Match(
id=Match.renderKeyName(
event.key.id(),
match.get("comp_level", None),
match.get("set_number", 0),
match.get("match_number", 0)),
event=event.key,
year=event.year,
set_number=match.get("set_number", 0),
match_number=match.get("match_number", 0),
comp_level=match.get("comp_level", None),
team_key_names=match.get("team_key_names", None),
alliances_json=match.get("alliances_json", None)
)
for match in match_dicts]
MatchManipulator.createOrUpdate(matches)
# rankings
result = urlfetch.fetch(self.RANKINGS_URL.format(event.year, event_key, event_key))
if result.status_code != 200:
logging.warning('Unable to retreive url: ' + (self.RANKINGS_URL.format(event.year, event_key, event_key)))
else:
# convert into expected input format
rankings = list(csv.reader(StringIO.StringIO(result.content), delimiter=','))
event_details = EventDetails(
id=event_key,
rankings=rankings
)
EventDetailsManipulator.createOrUpdate(event_details)
self.response.out.write("Done restoring {}!".format(event_key))
def test_updateMerge_no_auto_union(self):
self.assertMergedAward(
AwardManipulator.updateMerge(self.new_award,
self.old_award,
auto_union=False), False)
def resetAll(self, flushed=False):
response = self.testapp.get('/api/v2/events/2010', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
EventManipulator.createOrUpdate(self.event_2010sc_1)
if flushed:
self.assertEqual(memcache.get(self.eventlist_2010_cache_key), None)
TeamManipulator.createOrUpdate(self.team_frc1_1)
TeamManipulator.createOrUpdate(self.team_frc2_1)
EventTeamManipulator.createOrUpdate(self.eventteam_2010sc_frc1)
EventTeamManipulator.createOrUpdate(self.eventteam_2010sc_frc2)
MatchManipulator.createOrUpdate(self.match1_1)
AwardManipulator.createOrUpdate(self.award1_1)
response = self.testapp.get('/api/v2/events/2010', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/event/2010sc', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/event/2010sc/teams', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/event/2010sc/matches', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/event/2010sc/stats', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/event/2010sc/rankings', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/event/2010sc/awards', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/team/frc1/2010', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc1_cache_key), None)
if flushed:
self.assertEqual(memcache.get(self.team_frc2_cache_key), None)
response = self.testapp.get('/api/v2/team/frc2/2010', headers={'X-TBA-App-Id': 'tba-tests:api-cache-clear-test:v01'})
self.assertNotEqual(memcache.get(self.eventlist_2010_cache_key), None)
self.assertNotEqual(memcache.get(self.event_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventteams_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventmatches_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventstats_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventrankings_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.eventawards_2010sc_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc1_cache_key), None)
self.assertNotEqual(memcache.get(self.team_frc2_cache_key), None)
def post(self, event_key_id):
self._require_admin()
event = Event.get_by_id(event_key_id)
event.prepAwardsMatchesTeams()
remap_teams = {}
for key, value in json.loads(self.request.get('remap_teams')).items():
remap_teams['frc{}'.format(key)] = 'frc{}'.format(value)
# Remap matches
for match in event.matches:
for old_team, new_team in remap_teams.items():
# Update team key names
for i, key in enumerate(match.team_key_names):
if key == old_team:
match.dirty = True
if new_team.isdigit(): # Only if non "B" teams
match.team_key_names[i] = new_team
else:
del match.team_key_names[i]
# Update alliances
for color in ['red', 'blue']:
for i, key in enumerate(match.alliances[color]['teams']):
if key == old_team:
match.dirty = True
match.alliances[color]['teams'][i] = new_team
match.alliances_json = json.dumps(match.alliances)
MatchManipulator.createOrUpdate(event.matches)
# Remap alliance selections
if event.alliance_selections:
for row in event.alliance_selections:
for choice in ['picks', 'declines']:
for old_team, new_team in remap_teams.items():
for i, key in enumerate(row[choice]):
if key == old_team:
row[choice][i] = new_team
# Remap rankings
if event.rankings:
for row in event.rankings:
for old_team, new_team in remap_teams.items():
if row[1] == old_team[3:]:
row[1] = new_team[3:]
EventDetailsManipulator.createOrUpdate(event.details)
# Remap awards
for award in event.awards:
for old_team, new_team in remap_teams.items():
# Update team keys
for i, key in enumerate(award.team_list):
if key.id() == old_team:
award.dirty = True
if new_team.isdigit(): # Only if non "B" teams
award.team_list[i] = ndb.Key(Team, new_team)
else:
del award.team_list[i]
# Update recipient list
for recipient in award.recipient_list:
if str(recipient['team_number']) == old_team[3:]:
award.dirty = True
recipient['team_number'] = new_team[3:]
award.recipient_json_list = [json.dumps(r) for r in award.recipient_list]
AwardManipulator.createOrUpdate(event.awards, auto_union=False)
self.redirect("/admin/event/" + event.key_name)
