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.event = Event(
id="2014casj",
event_short="casj",
event_type_enum=EventType.REGIONAL,
name="Silicon Valley Regional",
start_date=datetime.datetime(2014, 2, 27, 0, 0),
end_date=datetime.datetime(2014, 3, 1, 0, 0),
year=2014,
timezone_id="America/New_York",
)
self.event_dst = Event(
id="2014casj",
event_short="casj",
event_type_enum=EventType.REGIONAL,
name="Silicon Valley Regional",
start_date=datetime.datetime(2014, 3, 8, 0, 0),
end_date=datetime.datetime(2014, 3, 9, 0,
0), # chosen to span DST change
year=2014,
timezone_id="America/Los_Angeles",
)
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=".")
self.future_event = EventTestCreator.createFutureEvent(only_event=True)
self.present_event = EventTestCreator.createPresentEvent(
only_event=True)
self.past_event = EventTestCreator.createPastEvent(only_event=True)
self.event_starts_today = Event(
id="{}teststartstoday".format(datetime.datetime.now().year),
end_date=datetime.datetime.today() + datetime.timedelta(days=2),
event_short="teststartstoday",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Starts Today)",
start_date=datetime.datetime.today(),
year=datetime.datetime.now().year,
venue_address="123 Fake Street, California, USA",
website="http://www.google.com")
self.event_ends_today = Event(
id="{}testendstoday".format(datetime.datetime.now().year),
end_date=datetime.datetime.today(),
event_short="testendstoday",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Ends Today)",
start_date=datetime.datetime.today() - datetime.timedelta(days=2),
year=datetime.datetime.now().year,
venue_address="123 Fake Street, California, USA",
website="http://www.google.com")
def test_is_maybe_match_wrong_start(self):
event_one = Event(start_date=datetime.datetime(year=2020,
month=7,
day=14,
hour=0,
minute=0,
second=0),
end_date=datetime.datetime(year=2020,
month=7,
day=15,
hour=23,
minute=59,
second=59),
city="London",
state_prov="OH")
event_two = Event(start_date=datetime.datetime(year=2020,
month=7,
day=13,
hour=0,
minute=0,
second=0),
end_date=datetime.datetime(year=2020,
month=7,
day=15,
hour=23,
minute=59,
second=59),
city="London",
state_prov="OH")
self.assertFalse(
OffseasonEventHelper.is_maybe_match(event_one, event_two))
event_two.start_date = event_one.start_date
self.assertTrue(
OffseasonEventHelper.is_maybe_match(event_one, event_two))
def test_effective_season_year_next_year_ignore_non_official(self):
# Effective season should be next year
today = datetime.today()
# Insert an event that has already happened - otherwise we'll default to the current season
# This is to simulate offseason
Event(
id="{}testended".format(today.year),
end_date=today - timedelta(days=1),
event_short="testended",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Ends Tomorrow)",
start_date=today - timedelta(days=2),
year=today.year,
venue_address="123 Fake Street, Anytown, MI, USA",
website="http://www.google.com"
).put()
Event(
id="{}testendstomorrow".format(today.year),
end_date=today + timedelta(days=1),
event_short="testendstomorrow",
event_type_enum=EventType.OFFSEASON,
first_eid="5561",
name="Test Event (Ends Tomorrow)",
start_date=today,
year=today.year,
venue_address="123 Fake Street, Anytown, MI, USA",
website="http://www.google.com"
).put()
self.assertEqual(SeasonHelper.effective_season_year(), today.year + 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.event_nyny = Event(id="2016nyny",
name="NYC Regional",
event_type_enum=EventType.REGIONAL,
short_name="NYC",
event_short="nyny",
year=2016,
end_date=datetime(2016, 03, 27),
official=True,
start_date=datetime(2016, 03, 24),
timezone_id="America/New_York")
self.event_nyny.put()
self.event_micmp = Event(id="2016micmp",
name="Michigan District Champs",
event_type_enum=EventType.DISTRICT_CMP,
short_name="Michigan",
event_short="micmp",
year=2016,
end_date=datetime(2016, 03, 27),
official=True,
start_date=datetime(2016, 03, 24),
timezone_id="America/New_York",
playoff_type=PlayoffType.BRACKET_16_TEAM)
self.event_micmp.put()
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.future_event = EventTestCreator.createFutureEvent(only_event=True)
self.present_event = EventTestCreator.createPresentEvent(
only_event=True)
self.past_event = EventTestCreator.createPastEvent(only_event=True)
self.event_starts_today = Event(
id="{}teststartstoday".format(datetime.datetime.now().year),
end_date=datetime.datetime.today() + datetime.timedelta(days=2),
event_short="teststartstoday",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Starts Today)",
start_date=datetime.datetime.today(),
year=datetime.datetime.now().year,
venue_address="123 Fake Street, California, USA",
website="http://www.google.com")
self.event_ends_today = Event(
id="{}testendstoday".format(datetime.datetime.now().year),
end_date=datetime.datetime.today(),
event_short="testendstoday",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Ends Today)",
start_date=datetime.datetime.today() - datetime.timedelta(days=2),
year=datetime.datetime.now().year,
venue_address="123 Fake Street, California, USA",
website="http://www.google.com")
self.event_starts_tomorrow = Event(
id="{}teststartstomorrow".format(datetime.datetime.now().year),
end_date=datetime.datetime.today() + datetime.timedelta(days=3),
event_short="teststartstomorrow",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Starts Tomorrow)",
start_date=datetime.datetime.today() + datetime.timedelta(days=1),
year=datetime.datetime.now().year,
venue_address="123 Fake Street, California, USA",
website="http://www.google.com")
self.event_starts_tomorrow_tz = Event(
id="{}teststartstomorrow".format(datetime.datetime.now().year),
end_date=datetime.datetime.today() + datetime.timedelta(days=3),
event_short="teststartstomorrow",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Test Event (Starts Tomorrow)",
start_date=datetime.datetime.today() + datetime.timedelta(days=1),
year=datetime.datetime.now().year,
venue_address="123 Fake Street, California, USA",
website="http://www.google.com",
timezone_id="America/New_York",
)
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.maxDiff = None
with open('test_data/usfirst_html/usfirst_event_rankings_2012ct.html',
'r') as f:
good_rankings, _ = UsfirstEventRankingsParser.parse(f.read())
with open(
'test_data/usfirst_html/usfirst_event_rankings_2012ct_bad.html',
'r') as f:
bad_rankings, _ = UsfirstEventRankingsParser.parse(f.read())
self.old_event = Event(
id="2011ct",
end_date=datetime.datetime(2011, 4, 2, 0, 0),
event_short="ct",
event_type_enum=EventType.REGIONAL,
event_district_enum=DistrictType.NO_DISTRICT,
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",
rankings_json=json.dumps(good_rankings))
self.new_event = Event(
id="2011ct",
end_date=datetime.datetime(2011, 4, 2, 0, 0),
event_short="ct",
event_type_enum=EventType.REGIONAL,
event_district_enum=DistrictType.NO_DISTRICT,
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",
matchstats_json=json.dumps({
'oprs': {
'4255': 7.4877151786460301,
'2643': 27.285682906835952,
'852': 10.452538750544525,
'4159': 25.820137009871139,
'581': 18.513816255143144
}
}),
facebook_eid="7",
webcast_json=json.dumps([{
'type': 'ustream',
'channel': 'foo'
}]),
rankings_json=json.dumps(bad_rankings))
def test_is_direct_match_key_name(self):
tba_event_one = Event(year=2020, first_code='zor', event_short='zorr')
tba_event_two = Event(year=2020, first_code='iri', event_short='irii')
first_event = Event(year=2020, event_short='zor')
self.assertTrue(
OffseasonEventHelper.is_direct_match(tba_event_one, first_event))
self.assertFalse(
OffseasonEventHelper.is_direct_match(tba_event_two, first_event))
def create_events():
event1 = Event(id=1, client_id=ndb.Key(Client, 12345), name="3 Idiots",
description="3 Idiots is a beautiful movie.", duration=180)
event2 = Event(id=2, client_id=ndb.Key(Client, 12345), name="The Godzilla",
description="The godzilla is a dinosaur.", duration=180)
event3 = Event(id=3, client_id=ndb.Key(Client, 123456), name="Avengers Infinity wars",
description="Avenger Infinity wars is a movie by marvel.", duration=180)
event4 = Event(id=4, client_id=ndb.Key(Client, 123456), name="The Godzilla",
description="The godzilla is a dinosaur.", duration=180)
ndb.put_multi([event1, event2, event3, event4])
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<event_key:>', ApiEventRankingsController, 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.rankings = [
["Rank", "Team", "QS", "ASSIST", "AUTO", "T&C", "TELEOP", "Record (W-L-T)", "DQ", "PLAYED"],
["1", "1126", "20.00", "240.00", "480.00", "230.00", "478.00", "10-2-0", "0", "12"],
["2", "5030", "20.00", "200.00", "290.00", "220.00", "592.00", "10-2-0", "0", "12"],
["3", "250", "20.00", "70.00", "415.00", "220.00", "352.00", "10-2-0", "0", "12"]
]
self.event = Event(
id="2010sc",
name="Palmetto Regional",
event_type_enum=EventType.REGIONAL,
short_name="Palmetto",
event_short="sc",
year=2010,
end_date=datetime(2010, 03, 27),
official=True,
city="Clemson",
state_prov="SC",
country="USA",
start_date=datetime(2010, 03, 24)
)
self.event.put()
self.event_details = EventDetails(
id=self.event.key.id(),
rankings=self.rankings
)
self.event_details.put()
self.eventNoRanks = Event(
id="2010ct",
name="Palmetto Regional",
event_type_enum=EventType.REGIONAL,
short_name="Palmetto",
event_short="ct",
year=2010,
end_date=datetime(2010, 03, 27),
official=True,
city="Clemson",
state_prov="SC",
country="USA",
start_date=datetime(2010, 03, 24),
)
self.eventNoRanks.put()
def test_is_direct_match_key_name(self):
first_event_match = Event(year=2020, event_short='zor')
second_event_match = Event(year=2020, event_short='zor')
third_event_match = Event(year=2020, event_short='iri')
self.assertTrue(
OffseasonEventHelper.is_direct_match(first_event_match,
second_event_match))
self.assertFalse(
OffseasonEventHelper.is_direct_match(first_event_match,
third_event_match))
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
self.maxDiff = None
self.old_event = Event(
id="2011ct",
end_date=datetime.datetime(2011, 4, 2, 0, 0),
event_short="ct",
event_type_enum=EventType.REGIONAL,
district_key=None,
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",
webcast_json=json.dumps([{
'type': 'twitch',
'channel': 'bar'
}]),
)
self.new_event = Event(
id="2011ct",
end_date=datetime.datetime(2011, 4, 2, 0, 0),
event_short="ct",
event_type_enum=EventType.REGIONAL,
district_key=None,
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",
facebook_eid="7",
webcast_json=json.dumps([{
'type': 'ustream',
'channel': 'foo'
}]),
)
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
past_event = Event(
id="{}tstupdaterpast".format(CUR_YEAR),
end_date=datetime.datetime.now() - datetime.timedelta(days=1),
event_short="tstupdaterpast",
event_type_enum=EventType.REGIONAL,
start_date=datetime.datetime.now() - datetime.timedelta(days=2),
year=CUR_YEAR,
)
past_event.put()
past_event_matches = set_up_matches(
'test_data/usfirst_html/usfirst_event_matches_2012ct.html',
past_event)
ndb.put_multi(past_event_matches)
future_event = Event(
id="{}tstupdaterfuture".format(CUR_YEAR),
end_date=datetime.datetime.now() + datetime.timedelta(days=2),
event_short="tstupdaterfuture",
event_type_enum=EventType.REGIONAL,
start_date=datetime.datetime.now() + datetime.timedelta(days=1),
year=CUR_YEAR,
)
future_event.put()
future_event_matches = set_up_matches(
'test_data/usfirst_html/usfirst_event_matches_2012ct.html',
future_event)
ndb.put_multi(future_event_matches)
past_year_event = Event(
id="{}tstupdaterpastyear".format(CUR_YEAR - 1),
end_date=datetime.datetime.now() - datetime.timedelta(days=1),
event_short="tstupdaterpastyear",
event_type_enum=EventType.REGIONAL,
start_date=datetime.datetime.now() - datetime.timedelta(days=2),
year=CUR_YEAR - 1,
)
past_year_event.put()
past_year_event_matches = set_up_matches(
'test_data/usfirst_html/usfirst_event_matches_2012ct.html',
past_year_event)
ndb.put_multi(past_year_event_matches)
def test_parse2017Awards(self):
self.event = Event(
id="2017cmpmo",
end_date=datetime.datetime(2017, 4, 29, 0, 0),
event_short="cmpmo",
event_type_enum=EventType.CMP_FINALS,
district_key=None,
first_eid="22465",
name="Einstein Field (St. Louis)",
start_date=datetime.datetime(2017, 4, 29, 0, 0),
year=2017,
timezone_id='America/Chicago'
)
self.event.put()
with open('test_data/fms_api/2017cmpmo_awards.json', 'r') as f:
awards = FMSAPIAwardsParser(self.event).parse(json.loads(f.read()))
self.assertEqual(len(awards), 6)
for award in awards:
if award.key.id() == '2017cmpmo_0':
self.assertEqual(award.name_str, 'Chairman\'s Award')
self.assertEqual(award.award_type_enum, 0)
self.assertFalse({'team_number': 2169, 'awardee': None} in award.recipient_list)
self.assertFalse({'team_number': 1885, 'awardee': None} in award.recipient_list)
self.assertTrue({'team_number': 2614, 'awardee': None} in award.recipient_list)
elif award.key.id() == '2017cmpmo_69':
self.assertEqual(award.name_str, 'Chairman\'s Award Finalist')
self.assertEqual(award.award_type_enum, 69)
self.assertTrue({'team_number': 2169, 'awardee': None} in award.recipient_list)
self.assertTrue({'team_number': 1885, 'awardee': None} in award.recipient_list)
self.assertFalse({'team_number': 2614, 'awardee': None} in award.recipient_list)
def test_parse_playoff_with_octofinals(self):
self.event = Event(id="2016micmp",
name="Michigan District Champs",
event_type_enum=EventType.DISTRICT_CMP,
short_name="Michigan",
event_short="micmp",
year=2016,
end_date=datetime(2016, 03, 27),
official=True,
start_date=datetime(2016, 03, 24),
timezone_id="America/New_York")
self.event.put()
with open(
'test_data/fms_api/2016_micmp_staging_hybrid_schedule_playoff.json',
'r') as f:
matches = FMSAPIHybridScheduleParser(2016, 'micmp').parse(
json.loads(f.read()))
self.assertTrue(isinstance(matches, list))
self.assertEquals(len(matches), 36)
# Assert we get enough of each match type
clean_matches = MatchHelper.organizeMatches(matches)
self.assertEqual(len(clean_matches["ef"]), 20)
self.assertEqual(len(clean_matches["qf"]), 10)
self.assertEqual(len(clean_matches["sf"]), 4)
self.assertEqual(len(clean_matches["f"]), 2)
def test_parse_playoff(self):
self.event = Event(id="2016nyny",
name="NYC Regional",
event_type_enum=EventType.REGIONAL,
short_name="NYC",
event_short="nyny",
year=2016,
end_date=datetime(2016, 03, 27),
official=True,
start_date=datetime(2016, 03, 24),
timezone_id="America/New_York")
self.event.put()
with open('test_data/fms_api/2016_nyny_hybrid_schedule_playoff.json',
'r') as f:
matches = FMSAPIHybridScheduleParser(2016, 'nyny').parse(
json.loads(f.read()))
self.assertTrue(isinstance(matches, list))
self.assertEqual(len(matches), 15)
# Assert we get enough of each match type
clean_matches = MatchHelper.organizeMatches(matches)
self.assertEqual(len(clean_matches["ef"]), 0)
self.assertEqual(len(clean_matches["qf"]), 9)
self.assertEqual(len(clean_matches["sf"]), 4)
self.assertEqual(len(clean_matches["f"]), 2)
def test_zwaveep(self):
dispatcher = Dispatcher()
zwaveEP = ZwaveEP(dispatcher)
awsIotEP = AWSIotEP(dispatcher)
dispatcher.add_event_processor('zwave_ep', zwaveEP)
dispatcher.add_event_processor('awsiot_ep', awsIotEP)
event = Event()
event.timestamp = time.time()
event.source = 'zwave_net_id'
event.destination = 'zwave_ep'
event.payload = 'LIGHT-ON'
dispatcher.add_event(event)
time.sleep(1)
dispatcher.stop()
self.assertEqual(zwaveEP.dailyEventCount(), 1)
self.assertEqual(awsIotEP.dailyEventCount(), 1)
dispatcher.wait_until_shutdown()
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<year:>', ApiEventListController, 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.event = Event(
id="2010sc",
name="Palmetto Regional",
event_type_enum=EventType.REGIONAL,
short_name="Palmetto",
event_short="sc",
year=2010,
end_date=datetime(2010, 03, 27),
official=True,
city="Clemson",
state_prov="SC",
country="USA",
start_date=datetime(2010, 03, 24),
)
self.event.put()
def getEventsInPeriod(self, from_ts, till_ts):
params = {
'output': "extend",
'select_acknowledges': "extend",
'selectRelatedObject': "extend",
'selectTags': 'extend',
'selectHosts': 'extend',
#'time_from': "1546304400",
#'time_till': "1551096473",
'time_from': from_ts,
'time_till': till_ts,
'sortfield': ["clock", "eventid"],
'sortorder': "desc"
}
res = self.execute("event.get", params)
events = []
#print (json.dumps(res['result']))
for result in res['result']:
#print (result)
event = Event(result)
events.append(event)
#except:
#logging.error(result)
#print (f"collected {len(events)} events")
return events
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<event_key:>', ApiEventStatsController, 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.matchstats = {
"dprs": {"971": 10.52178695299036, "114": 23.7313645955704, "115": 29.559784481082044},
"oprs": {"971": 91.42946669932006, "114": 59.27751047482864, "115": 13.285278757495144},
"ccwms": {"971": 80.90767974632955, "114": 35.54614587925829, "115": -16.27450572358693},
}
self.event = Event(
id="2010sc",
name="Palmetto Regional",
event_type_enum=EventType.REGIONAL,
short_name="Palmetto",
event_short="sc",
year=2010,
end_date=datetime(2010, 03, 27),
official=True,
location='Clemson, SC',
start_date=datetime(2010, 03, 24),
matchstats_json=json.dumps(self.matchstats)
)
self.event.put()
def _create_candidate_event(cls, suggestion):
start_date = None
end_date = None
try:
start_date = datetime.strptime(suggestion.contents['start_date'], "%Y-%m-%d")
end_date = datetime.strptime(suggestion.contents['end_date'], "%Y-%m-%d")
except ValueError:
pass
venue = suggestion.contents['venue_name']
address = suggestion.contents['address']
city = suggestion.contents['city']
state = suggestion.contents['state']
country = suggestion.contents['country']
address = "{}\n{}\n{}, {}, {}".format(venue, address, city, state, country)
return suggestion.key.id(), Event(
end_date=end_date,
event_type_enum=EventType.OFFSEASON,
district_key=None,
venue=venue,
city=city,
state_prov=state,
country=country,
venue_address=address,
name=suggestion.contents['name'],
start_date=start_date,
website=suggestion.contents['website'],
year=start_date.year if start_date else None,
official=False)
def getProblems(self, from_ts, till_ts):
params = {
'output': "extend",
'select_acknowledges': "extend",
'selectRelatedObject': "extend",
'selectTags': 'extend',
'selectHosts': 'extend',
#'time_from': '1552003200',
#'time_till': '1551222000',
#1551052800
#'time_from': '1552089600',
'time_from': from_ts,
'time_till': till_ts,
'sortfield': ["clock", "eventid"],
'sortorder': "desc"
#'value': '1'
}
res = self.execute("event.get", params)
problems = []
#print (len(res['result']))
for result in res['result']:
#problem = Event(result)
if result['value'] == '1':
problem = Event(result)
#logging.warning(problem.to_dict())
if problem.description != "" and problem.host.name != "":
problems.append(problem)
return problems
def store_event(data):
event = Event(id=data['key'])
event.name = data['name']
event.short_name = data['short_name']
event.event_short = data['event_code']
event.event_type_enum = data['event_type']
event.year = data['year']
event.timezone_id = data['timezone']
event.website = data['website']
event.start_date = datetime.datetime.strptime(
data['start_date'],
EVENT_DATE_FORMAT_STR) if data['start_date'] else None
event.end_date = datetime.datetime.strptime(
data['end_date'], EVENT_DATE_FORMAT_STR) if data['end_date'] else None
event.webcast_json = json.dumps(data['webcasts'])
event.venue = data['location_name']
event.city = data['city']
event.state_prov = data['state_prov']
event.country = data['country']
event.playoff_type = data['playoff_type']
event.parent_event = ndb.Key(
Event, data['parent_event_key']) if data['parent_event_key'] else None
event.divisions = [
ndb.Key(Event, div_key) for div_key in data['division_keys']
] if data['division_keys'] else []
district = store_district(data['district']) if data['district'] else None
event.district_key = district.key if district else None
return EventManipulator.createOrUpdate(event)
def create():
name = request.json.get('name')
description = request.json.get('description')
location = request.json.get('location')
host = get_jwt_identity()
time = request.json.get('time')
max_number = request.json.get('max_number')
event = Event(name=name,
description=description,
location=location,
host=host,
time=time,
max_number=max_number)
if event.save():
print('event saved')
event = Event.get_by_id(event.id)
response = {
'message': 'Event successfully created',
'data': {
'name': event.name,
'description': event.description,
'location': event.location,
'host': event.host.id,
'max_number': event.max_number,
'time': event.time
}
}
return make_response(jsonify(response), 200)
else:
response = {'message': 'Event creation failed'}
return make_response(jsonify(response), 400)
def test_offseason(self):
for event_type in EventType.type_names.keys():
event = Event(event_type_enum=event_type)
if event_type in EventType.SEASON_EVENT_TYPES:
self.assertFalse(event.is_offseason)
else:
self.assertTrue(event.is_offseason)
def setUp(self):
self.event = Event(id="2013test", event_short="test", year=2013)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
def testOfficialEvent(self):
event = Event(id="2016test",
name="Test Event",
event_short="Test Event",
year=2016,
event_type_enum=EventType.REGIONAL)
event.put()
status = SuggestionCreator.createApiWriteSuggestion(
self.account.key, "2016test", "Event Organizer", [
AuthType.MATCH_VIDEO, AuthType.EVENT_MATCHES,
AuthType.EVENT_ALLIANCES
])
self.assertEqual(status, 'success')
# Ensure the Suggestion gets created with only MATCH_VIDEO permission
suggestions = Suggestion.query().fetch()
self.assertIsNotNone(suggestions)
self.assertEqual(len(suggestions), 1)
suggestion = suggestions[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.contents['event_key'], "2016test")
self.assertEqual(suggestion.contents['affiliation'], "Event Organizer")
self.assertListEqual(suggestion.contents['auth_types'],
[AuthType.MATCH_VIDEO])
def create_event():
if (request.method == 'GET'):
return render_template("form.html")
elif (request.method == 'POST'):
org_name = request.form['org_name']
location = request.form['location']
event_name = request.form['event_name']
email = request.form['email']
date = request.form['date']
time = request.form['time']
url = request.form['url']
description = request.form['description']
prev_saturday, next_saturday = get_prev_and_next_sat(date)
geometry = get_geometry_for_address(location)
e = Event(event_name,
datetime.datetime.now(),
location,
url,
description,
-1,
org_name,
0,
"",
prev_saturday,
next_saturday,
latitude=geometry["lat"],
longitude=geometry["lng"])
dbhelper.createEvent(e)
return redirect(url_for('index'))
def testWebcastGoodDate(self):
event = Event(id="2016test",
name="Test Event",
event_short="Test Event",
year=2016,
event_type_enum=EventType.OFFSEASON)
event.put()
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key, "http://twitch.tv/frcgamesense", "2017-02-28",
"2016test")
self.assertEqual(status, 'success')
suggestions = Suggestion.query().fetch()
self.assertIsNotNone(suggestions)
self.assertEqual(len(suggestions), 1)
suggestion = suggestions[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.target_key, "2016test")
self.assertEqual(suggestion.author, self.account.key)
self.assertEqual(suggestion.review_state, Suggestion.REVIEW_PENDING)
self.assertIsNotNone(suggestion.contents)
self.assertEqual(suggestion.contents.get('webcast_url'),
"http://twitch.tv/frcgamesense")
self.assertIsNotNone(suggestion.contents.get('webcast_dict'))
self.assertEqual(suggestion.contents.get('webcast_date'), "2017-02-28")
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.account = Account.get_or_insert("123",
email="*****@*****.**",
registered=True)
self.account.put()
event = Event(id="2016test",
name="Test Event",
event_short="Test Event",
year=2016,
event_type_enum=EventType.OFFSEASON)
event.put()
self.match = Match(id="2016test_f1m1",
event=ndb.Key(Event, "2016test"),
year=2016,
comp_level="f",
set_number=1,
match_number=1,
alliances_json='')
self.match.put()
