def _upload_stats(team_name, stats):
query = Team.all()
query.filter('name =', team_name)
result = query.fetch(1)
if len(result) > 0:
for team in result:
team.year = Const.LAST_YEAR
team.offense_passing = stats['offense']['pass']
team.offense_rushing = stats['offense']['rush']
team.offense_first_down = stats['offense']['first_down']
team.defense_passing = stats['defense']['pass']
team.defense_rushing = stats['defense']['rush']
team.defense_first_down = stats['defense']['first_down']
team.put()
else:
team = Team(name = team_name,
year = Const.LAST_YEAR,
offense_passing = stats['offense']['pass'],
offense_rushing = stats['offense']['rush'],
offense_first_down = stats['offense']['first_down'],
defense_passing = stats['defense']['pass'],
defense_rushing = stats['defense']['rush'],
defense_first_down = stats['defense']['first_down'])
team.put()
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 create_client(user, params):
name = params.get("name", "")
if not name or len(name) > 30:
return {"error_code":20251, "msg":"name invalid"}
#team = Team.select().where(Team.user == user, Team.name == name).first()
team = Team.select().where(Team.user == user).first()
if team:
return {"error_code":20252, "msg":"team is exists and must one"}
team_id = GUID.guid()
team = Team()
team.id = team_id
team.user = user
team.name = name
team.status = "normal"
team.team_type = 'client'
team.logo = widget.logo()
team.save(force_insert=True)
user.to_req = True
user.identify = "c%s" % team.id
user.save()
team_profile = TeamProfile()
team_profile.team = team
team_profile.save()
#Member.create(user=user, team=team, mtype='owner')
return {"error_code":0, "msg":"ok"}
class TestTeamMediaApiController(unittest2.TestCase):
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>/<year:>', ApiTeamMediaController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc254",
name="very long name",
team_number=254,
nickname="Teh Chezy Pofs",
address="Greenville, SC, USA"
)
self.team.put()
self.cdmedia = Media(
key=ndb.Key('Media', 'cdphotothread_39894'),
details_json=u'{"image_partial": "fe3/fe38d320428adf4f51ac969efb3db32c_l.jpg"}',
foreign_key=u'39894',
media_type_enum=1,
references=[ndb.Key('Team', 'frc254')],
year=2014)
self.cdmedia.put()
self.cddetails = dict()
self.cddetails["image_partial"] = "fe3/fe38d320428adf4f51ac969efb3db32c_l.jpg"
self.ytmedia = Media(
key=ndb.Key('Media', 'youtube_aFZy8iibMD0'),
details_json=None,
foreign_key=u'aFZy8iibMD0',
media_type_enum=0,
references=[ndb.Key('Team', 'frc254')],
year=2014)
self.ytmedia.put()
def tearDown(self):
self.testbed.deactivate()
def testTeamMediaApi(self):
response = self.testapp.get('/frc254/2014', headers={"X-TBA-App-Id": "tba-tests:team_media-controller-test:v01"})
media = json.loads(response.body)
self.assertEqual(len(media), 2)
cd = media[0]
self.assertEqual(cd["type"], "cdphotothread")
self.assertEqual(cd["foreign_key"], "39894")
self.assertEqual(cd["details"], self.cddetails)
yt = media[1]
self.assertEqual(yt["type"], "youtube")
self.assertEqual(yt["foreign_key"], "aFZy8iibMD0")
self.assertEqual(yt["details"], {})
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<page_num:([0-9]*)>', ApiTeamListController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team1 = Team(
id="frc123",
name="SomeName",
team_number=123,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team2 = Team(
id="frc4567",
name="SomeName",
team_number=4567,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team1.put()
self.team2.put()
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
event = Event(
id="2011ct",
end_date=datetime.datetime(2011, 4, 2, 0, 0),
event_short="ct",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Northeast Utilities FIRST Connecticut Regional",
start_date=datetime.datetime(2011, 3, 31, 0, 0),
year=2011,
venue_address="Connecticut Convention Center\r\n100 Columbus Blvd\r\nHartford, CT 06103\r\nUSA",
website="http://www.ctfirst.org/ctr"
)
event.put()
team = Team(
id="frc177",
team_number=177,
website="http://www.bobcatrobotics.org"
)
team.put()
event_team = EventTeam(
id="%s_%s" % (event.key.id(), team.key.id()),
event=event.key,
team=team.key,
year=None)
event_team.put()
def get(self, page_num=0):
self._require_admin()
page_num = int(page_num)
if page_num < self.MAX_PAGE:
start = self.PAGE_SIZE * page_num
end = start + self.PAGE_SIZE
teams = Team.query(Team.team_number >= start, Team.team_number < end).order(Team.team_number).fetch()
else:
start = self.PAGE_SIZE * self.MAX_PAGE
teams = Team.query(Team.team_number >= start).order(Team.team_number).fetch()
page_labels = []
for page in xrange(self.MAX_PAGE):
if page == 0:
page_labels.append('1-999')
else:
page_labels.append('{}\'s'.format(1000 * page))
page_labels.append('{}+'.format(1000 * self.MAX_PAGE))
self.template_values.update({
"teams": teams,
"num_teams": Team.query().count(),
"page_num": page_num,
"page_labels": page_labels,
})
path = os.path.join(os.path.dirname(__file__), '../../templates/admin/team_list.html')
self.response.out.write(template.render(path, 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)
class TestTeamListApiController(unittest2.TestCase):
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<page_num:([0-9]*)>', ApiTeamListController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team1 = Team(
id="frc123",
name="SomeName",
team_number=123,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team2 = Team(
id="frc4567",
name="SomeName",
team_number=4567,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team1.put()
self.team2.put()
def tearDown(self):
self.testbed.deactivate()
def assertTeam1Json(self, team):
self.assertEqual(team["key"], self.team1.key_name)
self.assertEqual(team["name"], self.team1.name)
self.assertEqual(team["team_number"], self.team1.team_number)
def assertTeam2Json(self, team):
self.assertEqual(team["key"], self.team2.key_name)
self.assertEqual(team["name"], self.team2.name)
self.assertEqual(team["team_number"], self.team2.team_number)
def testTeamListApi(self):
response = self.testapp.get('/0', headers={"X-TBA-App-Id": "tba-tests:team_list-controller-test:v01"})
team_list = json.loads(response.body)
self.assertTeam1Json(team_list[0])
response = self.testapp.get('/9', headers={"X-TBA-App-Id": "tba-tests:team_list-controller-test:v01"})
team_list = json.loads(response.body)
self.assertTeam2Json(team_list[0])
response = self.testapp.get('/10', headers={"X-TBA-App-Id": "tba-tests:team_list-controller-test:v01"})
team_list = json.loads(response.body)
self.assertEqual(team_list, [])
class TestDistrictTeamsApiController(unittest2.TestCase):
def setUp(self):
app = webapp2.WSGIApplication(
[webapp2.Route(r"/<district_abbrev:>/<year:([0-9]*)>", ApiDistrictTeamsController, methods=["GET"])],
debug=True,
)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache() # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc281",
name="Michelin / Caterpillar / Greenville Technical College /\
jcpenney / Baldor / ASME / Gastroenterology Associates /\
Laserflex South & Greenville County Schools & Greenville\
Technical Charter High School",
team_number=281,
nickname="EnTech GreenVillians",
city="Greenville",
state_prov="SC",
country="USA",
website="www.entech.org",
motto="Infiltrating Young Minds One Robot at a Time",
)
self.district_team = DistrictTeam(id="2015ne_frc281", team=self.team.key, year=2015, district=3)
self.team.put()
self.district_team.put()
def tearDown(self):
self.testbed.deactivate()
def assertTeamJson(self, team):
team = team[0]
self.assertEqual(team["key"], self.team.key_name)
self.assertEqual(team["team_number"], self.team.team_number)
self.assertEqual(team["nickname"], self.team.nickname)
self.assertEqual(team["location"], self.team.location)
self.assertEqual(team["locality"], "Greenville")
self.assertEqual(team["country_name"], "USA")
self.assertEqual(team["region"], "SC")
self.assertEqual(team["website"], self.team.website)
self.assertEqual(team["motto"], self.team.motto)
def testDistrictsApi(self):
response = self.testapp.get(
"/ne/2015", headers={"X-TBA-App-Id": "tba-tests:team-districts-controller-test:v01"}
)
teams = json.loads(response.body)
self.assertTeamJson(teams)
def create_entry_from_params(self, params):
new_team = Team(title = params["title"],
description = params["description"],
location = params["location"],
league = params["league"],
ref_id = params["ref_id"])
new_team.put()
return new_team
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))
class TestDatafeedUsfirstLegacyTeams(unittest2.TestCase):
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_urlfetch_stub()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.datafeed = DatafeedUsfirstLegacy()
self.team177 = Team(
id="frc177",
team_number=177,
first_tpid=211521,
first_tpid_year=2014,
)
self.team177.put()
def tearDown(self):
self.testbed.deactivate()
def test_getTeamDetails(self):
team = self.datafeed.getTeamDetails(self.team177)
self.assertEqual(team.key.id(), 'frc177')
self.assertEqual(team.name, "United Technologies / ClearEdge Power / Gain Talent / EBA&D & South Windsor High School")
self.assertEqual(team.address, u"South Windsor, CT\xa0 USA")
self.assertEqual(team.nickname, "Bobcat Robotics")
self.assertEqual(team.rookie_year, 1995)
self.assertEqual(team.website, "http://www.bobcatrobotics.org")
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)
class TestDatafeedUsfirstTeams(unittest2.TestCase):
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_urlfetch_stub()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.datafeed = DatafeedUsfirst()
self.team177 = Team(
id="frc177",
team_number=177,
first_tpid=61771,
first_tpid_year=2012
)
self.team177.put()
def tearDown(self):
self.testbed.deactivate()
def test_getTeamDetails(self):
team = self.datafeed.getTeamDetails(self.team177)
## Broken as result of FIRST website redesign -gregmarra 20151122
# self.assertEqual(team.name, "UTC Power/Ensign Bickford Aerospace & Defense & South Windsor High School")
# self.assertEqual(team.address, u"South Windsor, CT, USA")
# self.assertEqual(team.nickname, "Bobcat Robotics")
# self.assertEqual(team.website, "http://www.bobcatrobotics.org")
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 store_team(data):
team = Team(id=data['key'])
team.team_number = data['team_number']
team.nickname = data['nickname']
team.name = data['name']
team.website = data['website']
team.rookie_year = data['rookie_year']
team.motto = data['motto']
team.city = data['city']
team.state_prov = data['state_prov']
team.country = data['country']
TeamManipulator.createOrUpdate(team)
return team
class TestTeamApiController(unittest2.TestCase):
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc281",
name="Michelin / Caterpillar / Greenville Technical College /\
jcpenney / Baldor / ASME / Gastroenterology Associates /\
Laserflex South & Greenville County Schools & Greenville\
Technical Charter High School",
team_number=281,
rookie_year=1999,
nickname="EnTech GreenVillians",
city="Greenville",
state_prov="SC",
country="USA",
website="www.entech.org",
motto = "Infiltrating Young Minds One Robot at a Time",
)
self.team.put()
def tearDown(self):
self.testbed.deactivate()
def assertTeamJson(self, team):
self.assertEqual(team["key"], self.team.key_name)
self.assertEqual(team["team_number"], self.team.team_number)
self.assertEqual(team["nickname"], self.team.nickname)
self.assertEqual(team["location"], self.team.location)
self.assertEqual(team["locality"], "Greenville")
self.assertEqual(team["country_name"], "USA")
self.assertEqual(team["region"], "SC")
self.assertEqual(team["website"], self.team.website)
self.assertEqual(team["rookie_year"], self.team.rookie_year)
self.assertEqual(team["motto"], self.team.motto)
def testTeamApi(self):
response = self.testapp.get('/frc281', headers={"X-TBA-App-Id": "tba-tests:team-controller-test:v01"})
team_dict = json.loads(response.body)
self.assertTeamJson(team_dict)
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 _process_project(self, project):
team = Team.objects(team_id=project.namespace.id).first()
# We reset team statistics when we first encounter it
if team and project.namespace.id not in self.teams_seen:
team.delete()
team = None
self.teams_seen.add(project.namespace.id)
if not team:
team = Team(team_id=project.namespace.id)
for (lang, total) in self._lang_stats(project).items():
if lang in team.languages:
team.languages[lang] += total
else:
team.languages[lang] = total
team.save()
def delete(self, *args, **kwargs):
if 'user' not in kwargs or not args:
self.raise401()
user = kwargs['user']
path = parse_path(args[0])
team = Team.objects(name=path[0]).first()
if not team or user not in team.members:
self.raise401()
try:
Team.objects(name=path[0]).delete()
self.set_status(204)
self.finish()
except Exception as e:
reason = e.message
self.raise400(reason=reason)
class TestTeamHistoryDistrictsApiController(unittest2.TestCase):
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamHistoryDistrictsController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache() # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc1124",
name="UberBots",
team_number=1124,
nickname="UberBots"
)
self.district_team = DistrictTeam(
id="2015ne_frc1124",
team=self.team.key,
year=2015,
district_key=ndb.Key(District, '2015ne')
)
self.district = District(
id='2015ne',
year=2015
)
self.team.put()
self.district_team.put()
self.district.put()
def tearDown(self):
self.testbed.deactivate()
def testDistrictsApi(self):
response = self.testapp.get('/frc1124', headers={"X-TBA-App-Id": "tba-tests:team-history-districts-controller-test:v01"})
district_dict = json.loads(response.body)
self.assertTrue("2015" in district_dict)
district_key = district_dict["2015"]
self.assertEqual(district_key, "2015ne")
def get(self):
team_keys_future = Team.query().order(Team.team_number).fetch_async(keys_only=True)
social_media_keys_future = Media.query(Media.year == None).fetch_async(keys_only=True)
team_futures = ndb.get_multi_async(team_keys_future.get_result())
social_futures = ndb.get_multi_async(social_media_keys_future.get_result())
socials_by_team = defaultdict(dict)
for social_future in social_futures:
social = social_future.get_result()
for reference in social.references:
socials_by_team[reference.id()][social.media_type_enum] = social
if team_futures:
with cloudstorage.open(self.TEAMS_FILENAME_PATTERN, 'w') as teams_file:
writer = csv.writer(teams_file, delimiter=',')
for team_future in team_futures:
team = team_future.get_result()
team_row = [team.key.id(), team.nickname, team.name, team.city, team.state_prov, team.country, team.website, team.rookie_year]
for social_type in MediaType.social_types:
social = socials_by_team[team.key.id()].get(social_type, None)
team_row.append(social.social_profile_url if social is not None else None)
self._writerow_unicode(writer, team_row)
self.response.out.write("Done backing up teams!")
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 get(self):
team_key = self.request.get("team_key")
year_str = self.request.get("year")
self._require_registration()
if not team_key or not year_str:
self.redirect("/", abort=True)
year = int(year_str)
team_future = Team.get_by_id_async(self.request.get("team_key"))
team = team_future.get_result()
if not team:
self.redirect("/", abort=True)
media_key_futures = Media.query(Media.references == team.key, Media.year == year).fetch_async(500, keys_only=True)
media_futures = ndb.get_multi_async(media_key_futures.get_result())
medias = [media_future.get_result() for media_future in media_futures]
medias_by_slugname = MediaHelper.group_by_slugname(medias)
self.template_values.update({
"status": self.request.get("status"),
"team": team,
"year": year,
"medias_by_slugname": medias_by_slugname,
})
self.response.out.write(jinja2_engine.render('suggestions/suggest_team_media.html', self.template_values))
def main(key, url):
print "Configuring GAE Remote API on {} to import {}".format(url, key)
if 'localhost' in url:
remote_api_stub.ConfigureRemoteApi(None, '/_ah/remote_api', local_auth_func, url)
else:
remote_api_stub.ConfigureRemoteApiForOAuth(url, '/_ah/remote_api')
print "Loading data from The Blue Alliance requires an API key"
print "Please go to https://thebluealliance.com/account and generate a read API key"
apiv3_key = raw_input("Enter your API key: ")
global AUTH_TOKEN
AUTH_TOKEN = apiv3_key
if Match.validate_key_name(key):
match_data = fetch_match(key)
store_match(match_data)
elif Event.validate_key_name(key):
update_event(key)
elif Team.validate_key_name(key):
team_data = fetch_team(key)
store_team(team_data)
elif key.isdigit():
event_keys = [event['key'] for event in fetch_endpoint('events/{}'.format(key))]
for event in event_keys:
update_event(event)
else:
print "Unknown key :("
def get(self):
team_keys = Team.query().fetch(keys_only=True)
for team_key in team_keys:
taskqueue.add(
queue_name='search-index-update',
url='/tasks/do/update_team_search_index/' + team_key.id(),
method='GET')
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):
self._validate_tba_app_id()
memcache_key = "csv_teams_all"
output = memcache.get(memcache_key)
if output is None:
team_keys = Team.query().order(Team.team_number).fetch(10000, keys_only=True)
team_futures = ndb.get_multi_async(team_keys)
sio = StringIO.StringIO()
writer = csv.writer(sio, delimiter=',')
writer.writerow(['team_number','name','nickname','location','website'])
for team_future in team_futures:
team = team_future.get_result()
row = [team.team_number, team.name, team.nickname, team.location, team.website]
row_utf8 = [unicode(e).encode('utf-8') for e in row]
writer.writerow(row_utf8)
output = sio.getvalue()
if tba_config.CONFIG["memcache"]:
memcache.set(memcache_key, output, 86400)
self.response.headers["content-type"] = "text/csv"
self.response.out.write(output)
self._track_call_defer('teams/list')
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamHistoryDistrictsController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc1124",
name="UberBots",
team_number=1124,
nickname="UberBots",
)
self.district_team = DistrictTeam(
id="2015ne_frc1124",
team=self.team.key,
year=2015,
district=3
)
self.team.put()
self.district_team.put()
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc281",
name="Michelin / Caterpillar / Greenville Technical College /\
jcpenney / Baldor / ASME / Gastroenterology Associates /\
Laserflex South & Greenville County Schools & Greenville\
Technical Charter High School",
team_number=281,
rookie_year=1999,
nickname="EnTech GreenVillians",
address="Greenville, SC, USA",
website="www.entech.org",
motto = "Infiltrating Young Minds One Robot at a Time",
)
self.team.put()
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 im_session_verify(params):
token = params.get("session_token")
session = Session.select().where(Session.session_key==token, Session.expire_at>utils.now()).first()
if not session:
return {"error_code":1, "msg":"token not exist"}
user = session.user
role, tid = user.app_identify[0], int(user.app_identify[1:])
if role == "f":
return {"error_code":0, "msg":"ok", "id":user.id}
team = Team.select().where(Team.id == tid).first()
if not team:
return {"error_code":1, "msg":"token error"}
return {"error_code":0, "msg":"ok", "id":team.id}
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 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 setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
for team_number in range(7):
Team(id="frc%s" % team_number, team_number=team_number).put()
self.event = EventTestCreator.createPresentEvent()
self.match = self.event.matches[0]
self.notification = MatchScoreNotification(self.match)
def setUp(self):
app = webapp2.WSGIApplication([
webapp2.Route(r'/<district_abbrev:>/<year:([0-9]*)>',
ApiDistrictTeamsController,
methods=['GET'])
],
debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc281",
name="Michelin / Caterpillar / Greenville Technical College /\
jcpenney / Baldor / ASME / Gastroenterology Associates /\
Laserflex South & Greenville County Schools & Greenville\
Technical Charter High School",
team_number=281,
nickname="EnTech GreenVillians",
city="Greenville",
state_prov="SC",
country="USA",
website="www.entech.org",
motto="Infiltrating Young Minds One Robot at a Time",
)
self.district_team = DistrictTeam(id="2015ne_frc281",
team=self.team.key,
year=2015,
district=3)
self.team.put()
self.district_team.put()
def __readModelListFromJSONFile(
modelType: str,
JSONFile: list) -> Union[None, List[Driver], List[Team]]:
"""
DEPRECATED: Returns a list of models from model list based on model type.
Pseudo-private method that takes in a model type, reads each model from the model list and returns them in a list
of relevant model objects. If the model list is empty, that means the list and subsequent file was just created;
hence there is no data to read and the function returns nothing.
:param modelType: Type of model being loaded
:type modelType: string
:param JSONFile: JSON file with models
:type JSONFile: list
:return: Models initialized as their relevant objects
:rtype: list
"""
# There is no need for a validation message here as it is okay to not have data in the model list.
if not JSONFile:
return
bar = __createProgressBar().start()
i = 0
if modelType.lower() in MODEL_TYPE_DICT.get('models').get('driverSubset'):
driverList = []
for tempDriver in JSONFile:
print(tempDriver)
driverList.append(Driver(tempDriver))
bar.update(i + 1)
bar.finish()
print()
return driverList
elif modelType.lower() in MODEL_TYPE_DICT.get('models').get('teamSubset'):
teamList = []
for tempTeam in JSONFile:
teamList.append(Team(tempTeam))
bar.update(i + 1)
bar.finish()
print()
return teamList
else:
raise Exception("Incorrect model type!")
def get(self):
"""
Enqueues TeamEventsGet for teams numbers <= 999 (these teams participated
in events from 2002 and prior, which we can't scrape normally)
"""
team_keys = Team.query(Team.team_number <= 999).fetch(10000, keys_only=True)
teams = ndb.get_multi(team_keys)
for team in teams:
taskqueue.add(
queue_name='usfirst',
url='/tasks/get/usfirst_pre2003_team_events/{}'.format(team.key_name),
method='GET')
self.response.out.write("Pre 2003 event gets have been enqueued for %s teams." % (len(teams)))
def get(self):
offset = int(self.request.get("offset", 0))
team_keys = Team.query().fetch(1000, offset=int(offset), keys_only=True)
teams = ndb.get_multi(team_keys)
for team in teams:
taskqueue.add(
queue_name='usfirst',
url='/tasks/get/usfirst_team_details/' + team.key_name,
method='GET')
# FIXME omg we're just writing out? -gregmarra 2012 Aug 26
self.response.out.write("%s team gets have been enqueued offset from %s.<br />" % (len(teams), offset))
self.response.out.write("Reload with ?offset=%s to enqueue more." % (offset + len(teams)))
def get_mentions_from_text(text):
try:
from models.team import Team
except ImportError:
from mikoto.libs.mock import Team
recipients = RE_USER_MENTION.findall(text)
users = set()
for _, r in recipients:
t = Team.get_by_uid(r)
if t:
users.update(t.all_members)
else:
users.add(r)
return list(users)
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache() # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
for team_number in range(7):
Team(id="frc%s" % team_number,
team_number=team_number).put()
self.events = []
def _render(self, page_num):
page_num = int(page_num)
start = self.PAGE_SIZE * page_num
end = start + self.PAGE_SIZE
team_keys = Team.query(Team.team_number >= start,
Team.team_number < end).fetch(None,
keys_only=True)
team_futures = ndb.get_multi_async(team_keys)
team_list = [
ModelToDict.teamConverter(team_future.get_result())
for team_future in team_futures
]
return json.dumps(team_list, ensure_ascii=True)
def teams(league):
teams = []
sql = "SELECT * FROM teams WHERE league_id = %s ORDER BY teams.points DESC, teams.goal_difference DESC, teams.goals_for DESC, teams.name ASC"
values = [league.id]
results = run_sql(sql, values)
for result in results:
team = Team(league, result['name'], result['games_played'],
result['wins'], result['draws'], result['losses'],
result['goals_for'], result['goals_against'],
result['goal_difference'], result['points'], result['id'])
teams.append(team)
return teams
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache()
self.testbed.init_taskqueue_stub(root_path=".")
for team_number in range(7):
Team(id="frc%s" % team_number, team_number=team_number).put()
self.event = EventTestCreator.createPresentEvent()
self.notification = AllianceSelectionNotification(self.event)
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<page_num:([0-9]*)>', ApiTeamListController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache() # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
self.team1 = Team(
id="frc123",
name="SomeName",
team_number=123,
nickname="SomeNickname",
city="San Jose",
state_prov="CA",
country="USA",
website="www.website.com",
)
self.team2 = Team(
id="frc4567",
name="SomeName",
team_number=4567,
nickname="SomeNickname",
city="San Jose",
state_prov="CA",
country="USA",
website="www.website.com",
)
self.team1.put()
self.team2.put()
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 quit_team():
"""
退出团队并清空相应权限
参数
{
"uid":"用户ID",
"team_id":"团队ID"
}
返回:
{
"code":0,
"message":""
}
"""
if not session.get("uid"):
return make_response(-1, message="请先登录")
operator: User = User.by_id(session.get("uid"))
user: User = User.by_id(request.form["uid"])
team: Team = Team.by_id(request.form["team_id"])
if user.id != operator.id and not permission_manager.has_permission(
operator.id, "team.manage"
) and operator.id not in team.admins and operator.id != team.owner_id:
return make_response(-1, message="你没有权限这样做")
relation = db.session.query(TeamMember).filter_by(
uid=user.id, team_id=team.id).one_or_none()
if not relation:
return make_response(-1, message="您不在此团队内")
if user.id == team.owner_id:
return make_response(-1, message="此用户不可被移出团队")
# def remove_and_return(a, val):
# a = a.copy()
# a.remove(val)
# return a
# # print(team.members)
# team.members = remove_and_return(team.members, user.id)
# user.joined_teams = remove_and_return(user.joined_teams, team.id)
# if user.id in team.admins:
# team.admins = remove_and_return(team.admins, user.id)
# print(team.members)
db.session.delete(relation)
db.session.commit()
perms = set((f"contest.use.{item}" for item in team.team_contests)) | set(
(f"problem.use.{item}" for item in team.team_problems)) | set(
(f"problemset.use.{item}" for item in team.team_problemsets))
user.permissions = [item for item in user.permissions if item not in perms]
db.session.commit()
permission_manager.refresh_user(user.id)
return make_response(0, message="操作完成")
def user_role_list(user):
profile = user.profile.first()
teams = Team.select().where(Team.user == user)
out = []
for team in teams:
out.append({"name": team.name, "team_id": team.uuid})
return {
"error_code": 0,
"msg": "ok",
"teams": out,
"name": profile.name,
"id": user.uuid
}
def setUp(self):
app = webapp2.WSGIApplication([
webapp2.Route(r'/<page_num:([0-9]*)>',
ApiTeamListController,
methods=['GET'])
],
debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team1 = Team(
id="frc123",
name="SomeName",
team_number=123,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team2 = Team(
id="frc4567",
name="SomeName",
team_number=4567,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team1.put()
self.team2.put()
def post(self, team=None, user_id=None, response=None):
args = self.parser.parse_args()
name = args["name"]
if user_id is not None:
if Team.query.filter_by(name=name).first():
response = ("Team with a similar name exists", 409)
else:
team = Team(name)
data = save_record(team)
response = ("Team %s created successfully" % name, 201)
return make_response(jsonify({
"message": response[0]
}), response[1])
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
self.old_team = Team(
id="frc177",
team_number=177,
rookie_year=1996,
first_tpid=61771,
first_tpid_year=2012,
)
self.new_team = Team(
id="frc177",
team_number=177,
rookie_year=1995,
website="http://www.bobcatrobotics.org",
)
def test_eventteams_update(self):
self.teams_auth.put()
team_list = ['frc254', 'frc971', 'frc604']
request_body = json.dumps(team_list)
# Insert teams into db, otherwise they won't get added (see 072058b)
Team(id='frc254', team_number=254).put()
Team(id='frc971', team_number=971).put()
Team(id='frc604', team_number=604).put()
Team(id='frc100', team_number=100).put()
request_path = '/api/trusted/v1/event/2014casj/team_list/update'
sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest()
response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True)
self.assertEqual(response.status_code, 200)
db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None)
self.assertEqual(len(db_eventteams), 3)
self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams])
self.assertTrue('2014casj_frc971' in [et.key.id() for et in db_eventteams])
self.assertTrue('2014casj_frc604' in [et.key.id() for et in db_eventteams])
team_list = ['frc254', 'frc100']
request_body = json.dumps(team_list)
sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest()
response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True)
self.assertEqual(response.status_code, 200)
db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None)
self.assertEqual(len(db_eventteams), 2)
self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams])
self.assertTrue('2014casj_frc100' in [et.key.id() for et in db_eventteams])
def get(self, model_type):
if model_type == 'events':
event_keys = Event.query().fetch(keys_only=True)
for event_key in event_keys:
taskqueue.add(
queue_name='admin',
url='/tasks/admin/do/run_event_post_update_hook/' + event_key.id(),
method='GET')
elif model_type == 'teams':
team_keys = Team.query().fetch(keys_only=True)
for team_key in team_keys:
taskqueue.add(
queue_name='admin',
url='/tasks/admin/do/run_team_post_update_hook/' + team_key.id(),
method='GET')
def get_events_per_user(self, event_id: int = None):
if event_id == None:
return [{
'user': user.name,
'events': Team.select().where(Team.member == user).count(),
'checked': 'unchecked'
} for user in User.select()]
else:
epu = []
for u in User.select():
checked = 'unchecked'
if Team.select().where((Team.member == u)
& (Team.event == event_id)):
checked = 'checked'
epu.append({
'user':
u.name,
'events':
Team.select().where(Team.member == u).count(),
'checked':
checked
})
return epu
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
self.event = Event(id='2020miket', event_short='miket', year=2020)
self.team = Team(id='frc7332', team_number=7332)
self.match = Match(id='2020miket_qm1',
event=self.event.key,
comp_level='qm',
set_number=1,
match_number=1)
def parse(self, response):
"""
Parse team info from FMSAPI
Returns a tuple of: list of models (Team, DistrictTeam, Robot),
and a Boolean indicating if there are more pages to be fetched
"""
# Get team json
# don't need to null check, if error, HTTP code != 200, so we wont' get here
current_page = response['pageCurrent']
total_pages = response['pageTotal']
teams = response['teams']
ret_models = []
for teamData in teams:
# concat city/state/country to get address
address = u"{}, {}, {}".format(teamData['city'],
teamData['stateProv'],
teamData['country'])
team = Team(id="frc{}".format(teamData['teamNumber']),
team_number=teamData['teamNumber'],
name=teamData['nameFull'],
nickname=teamData['nameShort'],
address=address,
website=teamData['website'],
rookie_year=teamData['rookieYear'])
districtTeam = None
if teamData['districtCode']:
districtAbbrev = DistrictType.abbrevs[
teamData['districtCode'].lower()]
districtTeam = DistrictTeam(id=DistrictTeam.renderKeyName(
self.year, districtAbbrev, team.key_name),
team=ndb.Key(Team, team.key_name),
year=self.year,
district=districtAbbrev)
robot = None
if teamData['robotName']:
robot = Robot(id=Robot.renderKeyName(team.key_name, self.year),
team=ndb.Key(Team, team.key_name),
year=self.year,
robot_name=teamData['robotName'].strip())
ret_models.append((team, districtTeam, robot))
return (ret_models, (current_page < total_pages))
def statistics_team_amount(body):
if filter(lambda x: x not in body, ["team_id", "amount"]):
return
team = Team.select().where(Team.id == int(body["team_id"])).first()
if not team:
return
ts = TeamStatistics().select().where(TeamStatistics.team == team).first()
if not ts:
ts = TeamStatistics()
ts.user = team.user
ts.team = team
ts.total_amount += utils.decimal_two(body["amount"])
ts.save()
return
def addTeam():
id = createId()
name = input("Ingrese el nombre del equipo: ")
championships = promptNumber(
"Ingrese la cantidad de coronas que ha ganado: ")
world_series = promptNumber(
"Ingrese la cantidad de series mundiales que ha ganado: ")
print(" Equipo agregado exitosamente!")
team = Team(id, name, championships, world_series)
database.team.addTeam(team)
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
for team_number in range(7):
Team(id="frc%s" % team_number, team_number=team_number).put()
self.event = EventTestCreator.createPresentEvent()
self.match = self.event.matches[0]
self.notification = UpcomingMatchNotification(self.match, self.event)
def user_all_info(cls):
if cls.user:
try:
_ = cls.user.profile.id
except:
cls.user.profile = cls.user.profile.first()
cls.user.profile.avatar = widget.avatar(cls.user.profile.avatar)
teams = Team.select(Team.id, Team.name, Team.uuid,
Team.logo).where(Team.user == cls.user,
Team.status == "normal")
cls.user.current_team = None
for x in teams:
x.logo = widget.logo(x.logo)
if x.id == int(cls.user.identify[1:]):
cls.user.current_team = x
cls.user.team = teams
