def create_insta_suggestion(account_key_id, team_num, year, insta_url):
SuggestionCreator.createTeamMediaSuggestion(
author_account_key=ndb.Key(Account, account_key_id),
media_url=insta_url,
team_key="frc{}".format(team_num),
year_str=str(year),
default_preferred=True)
def testMissingParameters(self):
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "", "2016-5-1", "2016-5-2", "http://foo.bar.com",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('name' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "", "2016-5-2",
"http://foo.bar.com", "123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('start_date' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "2016-5-1", "",
"http://foo.bar.com", "123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('end_date' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "2016-5-1", "2016-5-2", "",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('website' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "2016-5-1", "2016-5-2",
"http://foo.bar.com", "")
self.assertEqual(status, 'validation_failure')
self.assertTrue('venue_address' in failures)
def create_insta_suggestion(account_key_id, team_num, year, insta_url):
SuggestionCreator.createTeamMediaSuggestion(
author_account_key=ndb.Key(Account, account_key_id),
media_url=insta_url,
team_key="frc{}".format(team_num),
year_str=str(year),
default_preferred=True)
def testExistingSuggestion(self):
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(
self.account.key, "37F5tbrFqJQ", "2016test_f1m1")
self.assertEqual(status, 'success')
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(
self.account.key, "37F5tbrFqJQ", "2016test_f1m1")
self.assertEqual(status, 'suggestion_exists')
def createTeamMediaSuggestion(self):
user_bundle = UserBundle()
team = Team.query().fetch(1)[0]
SuggestionCreator.createTeamMediaSuggestion(
author_account_key=user_bundle.account.key,
media_url=self.YOUTUBE_URL,
team_key=team.key_name,
year_str="2016")
def createTeamMediaSuggestion(self):
user_bundle = UserBundle()
team = Team.query().fetch(1)[0]
SuggestionCreator.createTeamMediaSuggestion(
author_account_key=user_bundle.account.key,
media_url=self.YOUTUBE_URL,
team_key=team.key_name,
year_str="2016")
def get(self, year):
df = DatafeedFMSAPI('v2.0')
fmsapi_events, event_list_districts = df.getEventList(year)
# All regular-season events can be inserted without any work involved.
# We need to de-duplicate offseason events from the FRC Events API with a different code than the TBA event code
fmsapi_events_offseason = [e for e in fmsapi_events if e.is_offseason]
event_keys_to_put = set([e.key_name for e in fmsapi_events]) - set(
[e.key_name for e in fmsapi_events_offseason])
events_to_put = [
e for e in fmsapi_events if e.key_name in event_keys_to_put
]
matched_offseason_events, new_offseason_events = \
OffseasonEventHelper.categorize_offseasons(int(year), fmsapi_events_offseason)
# For all matched offseason events, make sure the FIRST code matches the TBA FIRST code
for tba_event, first_event in matched_offseason_events:
tba_event.first_code = first_event.event_short
events_to_put.append(
tba_event) # Update TBA events - discard the FIRST event
# For all new offseason events we can't automatically match, create suggestions
SuggestionCreator.createDummyOffseasonSuggestions(new_offseason_events)
events = EventManipulator.createOrUpdate(events_to_put) or []
fmsapi_districts = df.getDistrictList(year)
merged_districts = DistrictManipulator.mergeModels(
fmsapi_districts, event_list_districts)
if merged_districts:
districts = DistrictManipulator.createOrUpdate(merged_districts)
else:
districts = []
# Fetch event details for each event
for event in events:
taskqueue.add(queue_name='datafeed',
target='backend-tasks',
url='/backend-tasks/get/event_details/' +
event.key_name,
method='GET')
template_values = {
"events": events,
"districts": districts,
}
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/fms_event_list_get.html')
self.response.out.write(template.render(path, template_values))
def testMalformedDates(self):
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "meow", "2016-5-2",
"http://foo.bar.com", "123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('start_date' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "2016-5-1", "moo",
"http://foo.bar.com", "123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('end_date' in failures)
def testDuplicateUnknownSuggestionType(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://myweb.site/somewebcast", "", "2016test")
self.assertEqual(status, 'success')
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key, "http://myweb.site/somewebcast", "", "2016test")
self.assertEqual(status, 'suggestion_exists')
def testMissingParameters(self):
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"",
"2016-5-1",
"2016-5-2",
"http://foo.bar.com",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('name' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"Test Event",
"",
"2016-5-2",
"http://foo.bar.com",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('start_date' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"Test Event",
"2016-5-1",
"",
"http://foo.bar.com",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('end_date' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"Test Event",
"2016-5-1",
"2016-5-2",
"",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('website' in failures)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"Test Event",
"2016-5-1",
"2016-5-2",
"http://foo.bar.com",
"")
self.assertEqual(status, 'validation_failure')
self.assertTrue('venue_address' in failures)
def testDuplicateSuggestion(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", "", "2016test")
self.assertEqual(status, 'success')
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key, "http://twitch.tv/frcgamesense", "", "2016test")
self.assertEqual(status, 'suggestion_exists')
def testDuplicateSuggestion(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",
"2016test")
self.assertEqual(status, 'success')
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key,
"http://twitch.tv/frcgamesense",
"2016test")
self.assertEqual(status, 'suggestion_exists')
def testDuplicateUnknownSuggestionType(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://myweb.site/somewebcast",
"2016test")
self.assertEqual(status, 'success')
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key,
"http://myweb.site/somewebcast",
"2016test")
self.assertEqual(status, 'suggestion_exists')
def _render(self, team_key, year):
if int(year) not in list(TeamParticipationQuery(team_key).fetch()):
self.abort(404)
if 'media_url' in self.request.POST:
status, suggestion = SuggestionCreator.createTeamMediaSuggestion(
author_account_key=self.auth_owner_key,
media_url=self.request.POST["media_url"],
team_key=team_key,
year_str=year)
if status == 'success':
message = {
"success": True
}
else:
message = {
"success": False,
"message": status
}
else:
message = {
"success": False,
"message": "missing media_url"
}
return json.dumps(message, ensure_ascii=True, indent=2, sort_keys=True)
def post(self):
self._require_login()
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
author_account_key=self.user_bundle.account.key,
name=self.request.get("name", None),
start_date=self.request.get("start_date", None),
end_date=self.request.get("end_date", None),
website=self.request.get("website", None),
address=self.request.get("venue_address", None),
)
if status != 'success':
# Don't completely wipe form data if validation fails
self.template_values.update({
'status': status,
'failures': failures,
'name': self.request.get('name', None),
'start_date': self.request.get('start_date', None),
'end_date': self.request.get('end_date', None),
'website': self.request.get('website', None),
'venue_address': self.request.get('venue_address', None),
})
self.response.out.write(
jinja2_engine.render('suggest_offseason_event.html', self.template_values))
else:
self.redirect('/suggest/offseason?status=%s' % status)
def post(self):
self._require_registration()
event_key = self.request.get("event_key")
webcast_url = self.request.get("webcast_url")
webcast_date = self.request.get("webcast_date")
if not webcast_url:
self.redirect('/suggest/event/webcast?event_key={}&status=blank_webcast'.format(event_key), abort=True)
if ' ' in webcast_url:
# This is an invalid url
self.redirect('/suggest/event/webcast?event_key={}&status=invalid_url'.format(event_key), abort=True)
if 'thebluealliance' in webcast_url:
# TBA doesn't host webcasts, so we can reject this outright
self.redirect('/suggest/event/webcast?event_key={}&status=invalid_url'.format(event_key), abort=True)
status = SuggestionCreator.createEventWebcastSuggestion(
author_account_key=self.user_bundle.account.key,
webcast_url=self.request.get("webcast_url"),
webcast_date=self.request.get("webcast_date"),
event_key=event_key)
self.redirect('/suggest/event/webcast?event_key={}&status={}'.format(event_key, status))
def createSuggestion(self):
status = SuggestionCreator.createEventWebcastSuggestion(self.account.key,
'https://twitch.tv/frcgamesense',
'',
'2016necmp')
self.assertEqual(status, 'success')
return 'webcast_2016necmp_twitch_frcgamesense_None'
def testBadUrl(self):
status, _ = SuggestionCreator.createTeamMediaSuggestion(
self.account.key,
"http://foo.com/blah",
"frc1124",
"2016")
self.assertEqual(status, 'bad_url')
def testNoEvent(self):
status = SuggestionCreator.createApiWriteSuggestion(
self.account.key,
"2016test",
"Event Organizer",
[1, 2, 3])
self.assertEqual(status, 'bad_event')
def test_create_suggestion_banned(self):
status, _ = SuggestionCreator.createOffseasonEventSuggestion(
self.account_banned.key, "Test Event", "2016-5-1", "2016-5-2",
"http://foo.bar.com", "The Venue", "123 Fake Street", "New York",
"NY", "USA")
self.assertEqual(status, 'success')
# Ensure the Suggestion gets created
suggestions = Suggestion.query().fetch()
self.assertIsNotNone(suggestions)
self.assertEqual(len(suggestions), 1)
suggestion = suggestions[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.contents['name'], "Test Event")
self.assertEqual(suggestion.contents['start_date'], '2016-5-1')
self.assertEqual(suggestion.contents['end_date'], '2016-5-2')
self.assertEqual(suggestion.contents['website'], 'http://foo.bar.com')
self.assertEqual(suggestion.contents['address'], '123 Fake Street')
self.assertEqual(suggestion.contents['city'], 'New York')
self.assertEqual(suggestion.contents['state'], 'NY')
self.assertEqual(suggestion.contents['country'], 'USA')
self.assertEqual(suggestion.contents['venue_name'], 'The Venue')
self.assertEqual(suggestion.review_state,
Suggestion.REVIEW_AUTOREJECTED)
def post(self):
self._require_registration()
event_key = self.request.get("event_key")
if not event_key:
self.response.out.write("No event key found")
return
event_future = Event.get_by_id_async(event_key)
event = event_future.get_result()
if not event:
self.response.out.write("Invalid event key {}".format(event_key))
return
match_futures = Match.query(Match.event == event.key).fetch_async(keys_only=True)
valid_match_keys = [match.id() for match in match_futures.get_result()]
num_videos = int(self.request.get("num_videos", 0))
suggestions_added = 0
for i in range(0, num_videos):
yt_id = self.request.get("video_id_{}".format(i))
match_partial = self.request.get("match_partial_{}".format(i))
if not yt_id or not match_partial:
continue
match_key = "{}_{}".format(event_key, match_partial)
if match_key not in valid_match_keys:
continue
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(self.user_bundle.account.key, yt_id, match_key)
if status == 'success':
suggestions_added += 1
self.redirect('/suggest/event/video?event_key={}&num_added={}'.format(event_key, suggestions_added))
def test_create_suggestion_banned(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_banned.key, "http://twitch.tv/frcgamesense", "",
"2016test")
self.assertEqual(status, 'success')
# Ensure the Suggestion gets created
expected_key = "webcast_2016test_twitch_frcgamesense_None"
suggestion = Suggestion.get_by_id(expected_key)
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.target_key, "2016test")
self.assertEqual(suggestion.author, self.account_banned.key)
self.assertEqual(suggestion.review_state,
Suggestion.REVIEW_AUTOREJECTED)
self.assertIsNotNone(suggestion.contents)
self.assertEqual(suggestion.contents.get('webcast_url'),
"http://twitch.tv/frcgamesense")
self.assertIsNotNone(suggestion.contents.get('webcast_dict'))
def test_bad_event(self):
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key,
"http://twitch.tv/frcgamesense",
"",
"2016test")
self.assertEqual(status, 'bad_event')
def post(self):
self._require_registration()
event_name = self.request.get("name", None)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
author_account_key=self.user_bundle.account.key,
name=event_name,
start_date=self.request.get("start_date", None),
end_date=self.request.get("end_date", None),
website=self.request.get("website", None),
venue_name=self.request.get("venue_name", None),
address=self.request.get("venue_address", None),
city=self.request.get("venue_city", None),
state=self.request.get("venue_state", None),
country=self.request.get("venue_country", None)
)
if status != 'success':
# Don't completely wipe form data if validation fails
self.template_values.update({
'status': status,
'failures': failures,
'name': self.request.get('name', None),
'start_date': self.request.get('start_date', None),
'end_date': self.request.get('end_date', None),
'website': self.request.get('website', None),
'venue_address': self.request.get('venue_address', None),
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_offseason_event.html', self.template_values))
else:
subject, body = self._gen_notification_email(event_name)
OutgoingNotificationHelper.send_admin_alert_email(subject, body)
self.redirect('/suggest/offseason?status=%s' % status)
def post(self):
self._require_registration()
event_key = self.request.get("event_key")
status, suggestion = SuggestionCreator.createEventMediaSuggestion(
author_account_key=self.user_bundle.account.key,
media_url=self.request.get("media_url"),
event_key=event_key)
if status == 'success':
# Send an update to the FUN slack
slack_sitevar = Sitevar.get_or_insert('slack.hookurls')
if slack_sitevar:
slack_url = slack_sitevar.contents.get('fun', '')
if slack_url:
message_body = u"{0} ({1}) has suggested a video for <https://www.thebluealliance.com/event/{2}|{2}>: https://youtu.be/{3}.\nSee all suggestions at https://www.thebluealliance.com/suggest/event/media/review".format(
self.user_bundle.account.display_name,
self.user_bundle.account.email,
event_key,
suggestion.contents['foreign_key']).encode('utf-8')
OutgoingNotificationHelper.send_slack_alert(slack_url, message_body, [])
self.redirect('/suggest/event/media?event_key=%s&status=%s' % (event_key, status))
def createSuggestion(self):
status = SuggestionCreator.createEventWebcastSuggestion(self.account.key,
'https://twitch.tv/frcgamesense',
'',
'2016necmp')
self.assertEqual(status, 'success')
return 'webcast_2016necmp_twitch_frcgamesense_None'
def post(self):
self._require_registration()
event_key = self.request.get("event_key")
if not event_key:
self.response.out.write("No event key found")
return
event_future = Event.get_by_id_async(event_key)
event = event_future.get_result()
if not event:
self.response.out.write("Invalid event key {}".format(event_key))
return
match_futures = Match.query(Match.event == event.key).fetch_async(keys_only=True)
valid_match_keys = [match.id() for match in match_futures.get_result()]
num_videos = int(self.request.get("num_videos", 0))
suggestions_added = 0
for i in range(0, num_videos):
yt_id = self.request.get("video_id_{}".format(i))
match_partial = self.request.get("match_partial_{}".format(i))
if not yt_id or not match_partial:
continue
match_key = "{}_{}".format(event_key, match_partial)
if match_key not in valid_match_keys:
continue
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(self.user_bundle.account.key, yt_id, match_key)
if status == 'success':
suggestions_added += 1
self.redirect('/suggest/event/video?event_key={}&num_added={}'.format(event_key, suggestions_added))
def post(self):
self._require_registration()
event_name = self.request.get("name", None)
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
author_account_key=self.user_bundle.account.key,
name=event_name,
start_date=self.request.get("start_date", None),
end_date=self.request.get("end_date", None),
website=self.request.get("website", None),
venue_name=self.request.get("venue_name", None),
address=self.request.get("venue_address", None),
city=self.request.get("venue_city", None),
state=self.request.get("venue_state", None),
country=self.request.get("venue_country", None)
)
if status != 'success':
# Don't completely wipe form data if validation fails
self.template_values.update({
'status': status,
'failures': failures,
'name': self.request.get('name', None),
'start_date': self.request.get('start_date', None),
'end_date': self.request.get('end_date', None),
'website': self.request.get('website', None),
'venue_address': self.request.get('venue_address', None),
})
self.response.out.write(
jinja2_engine.render('suggest_offseason_event.html', self.template_values))
else:
subject, body = self._gen_notification_email(event_name)
SuggestionNotifier.send_admin_alert_email(subject, body)
self.redirect('/suggest/offseason?status=%s' % status)
def testOutOfOrderDates(self):
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "2016-5-4", "2016-5-2",
"http://foo.bar.com", "The Venue", "123 Fake Street", "New York",
"NY", "USA")
self.assertEqual(status, 'validation_failure')
self.assertTrue('end_date' in failures)
def createSuggestion(self):
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(
self.account.key, "H-54KMwMKY0", "2016necmp_f1m1")
self.assertEqual(status, 'success')
return Suggestion.render_media_key_name(2016, 'match',
'2016necmp_f1m1', 'youtube',
'H-54KMwMKY0')
def suggest_team_media(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return BaseResponse(code=401, message="Unauthorized to make suggestions")
user_id = PushHelper.user_email_to_id(current_user.email())
# For now, only allow team media suggestions
if request.reference_type != "team":
# Trying to suggest a media for an invalid model type
return BaseResponse(code=400, message="Bad model type")
# Need to split deletehash out into its own private dict. Don't want that to be exposed via API...
private_details_json = None
if request.details_json:
incoming_details = json.loads(request.details_json)
private_details = None
if 'deletehash' in incoming_details:
private_details = {'deletehash': incoming_details.pop('deletehash')}
private_details_json = json.dumps(private_details) if private_details else None
status = SuggestionCreator.createTeamMediaSuggestion(
author_account_key=ndb.Key(Account, user_id),
media_url=request.media_url,
team_key=request.reference_key,
year_str=str(request.year),
private_details_json=private_details_json)
if status != 'bad_url':
if status == 'success':
return BaseResponse(code=200, message="Suggestion added")
else:
return BaseResponse(code=304, message="Suggestion already exists")
else:
return BaseResponse(code=400, message="Bad suggestion url")
def test_webcast_good_date(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 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 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 post(self):
self._require_registration()
event_key = self.request.get("event_key")
webcast_url = self.request.get("webcast_url")
webcast_date = self.request.get("webcast_date")
if not webcast_url:
self.redirect(
'/suggest/event/webcast?event_key={}&status=blank_webcast'.
format(event_key),
abort=True)
if ' ' in webcast_url:
# This is an invalid url
self.redirect(
'/suggest/event/webcast?event_key={}&status=invalid_url'.
format(event_key),
abort=True)
if 'thebluealliance' in webcast_url:
# TBA doesn't host webcasts, so we can reject this outright
self.redirect(
'/suggest/event/webcast?event_key={}&status=invalid_url'.
format(event_key),
abort=True)
status = SuggestionCreator.createEventWebcastSuggestion(
author_account_key=self.user_bundle.account.key,
webcast_url=self.request.get("webcast_url"),
webcast_date=self.request.get("webcast_date"),
event_key=event_key)
self.redirect('/suggest/event/webcast?event_key={}&status={}'.format(
event_key, status))
def testBadUrl(self):
status = SuggestionCreator.createTeamMediaSuggestion(
self.account.key,
"http://foo.com/blah",
"frc1124",
"2016")
self.assertEqual(status, 'bad_url')
def test_no_event(self):
status = SuggestionCreator.createApiWriteSuggestion(
self.account.key,
"2016test",
"Event Organizer",
[1, 2, 3])
self.assertEqual(status, 'bad_event')
def post(self):
self._require_registration()
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
author_account_key=self.user_bundle.account.key,
name=self.request.get("name", None),
start_date=self.request.get("start_date", None),
end_date=self.request.get("end_date", None),
website=self.request.get("website", None),
address=self.request.get("venue_address", None),
)
if status != 'success':
# Don't completely wipe form data if validation fails
self.template_values.update({
'status':
status,
'failures':
failures,
'name':
self.request.get('name', None),
'start_date':
self.request.get('start_date', None),
'end_date':
self.request.get('end_date', None),
'website':
self.request.get('website', None),
'venue_address':
self.request.get('venue_address', None),
})
self.response.out.write(
jinja2_engine.render('suggest_offseason_event.html',
self.template_values))
else:
self.redirect('/suggest/offseason?status=%s' % status)
def suggest_team_media(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return BaseResponse(code=401, message="Unauthorized to make suggestions")
user_id = PushHelper.user_email_to_id(current_user.email())
# For now, only allow team media suggestions
if request.reference_type != "team":
# Trying to suggest a media for an invalid model type
return BaseResponse(code=400, message="Bad model type")
# Need to split deletehash out into its own private dict. Don't want that to be exposed via API...
private_details_json = None
if request.details_json:
incoming_details = json.loads(request.details_json)
private_details = None
if 'deletehash' in incoming_details:
private_details = {'deletehash': incoming_details.pop('deletehash')}
private_details_json = json.dumps(private_details) if private_details else None
status = SuggestionCreator.createTeamMediaSuggestion(
author_account_key=ndb.Key(Account, user_id),
media_url=request.media_url,
team_key=request.reference_key,
year_str=str(request.year),
private_details_json=private_details_json)
if status != 'bad_url':
if status == 'success':
return BaseResponse(code=200, message="Suggestion added")
else:
return BaseResponse(code=304, message="Suggestion already exists")
else:
return BaseResponse(code=400, message="Bad suggestion url")
def test_create_suggestion_banned(self):
status, _ = SuggestionCreator.createOffseasonEventSuggestion(
self.account_banned.key,
"Test Event",
"2016-5-1",
"2016-5-2",
"http://foo.bar.com",
"The Venue",
"123 Fake Street",
"New York", "NY", "USA")
self.assertEqual(status, 'success')
# Ensure the Suggestion gets created
suggestions = Suggestion.query().fetch()
self.assertIsNotNone(suggestions)
self.assertEqual(len(suggestions), 1)
suggestion = suggestions[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.contents['name'], "Test Event")
self.assertEqual(suggestion.contents['start_date'], '2016-5-1')
self.assertEqual(suggestion.contents['end_date'], '2016-5-2')
self.assertEqual(suggestion.contents['website'], 'http://foo.bar.com')
self.assertEqual(suggestion.contents['address'], '123 Fake Street')
self.assertEqual(suggestion.contents['city'], 'New York')
self.assertEqual(suggestion.contents['state'], 'NY')
self.assertEqual(suggestion.contents['country'], 'USA')
self.assertEqual(suggestion.contents['venue_name'], 'The Venue')
self.assertEqual(suggestion.review_state, Suggestion.REVIEW_AUTOREJECTED)
def testExistingVideo(self):
self.match.youtube_videos = ["37F5tbrFqJQ"]
self.match.put()
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(
self.account.key, "37F5tbrFqJQ", "2016test_f1m1")
self.assertEqual(status, 'video_exists')
def post(self):
self._require_registration()
event_key = self.request.get("event_key")
status, suggestion = SuggestionCreator.createEventMediaSuggestion(
author_account_key=self.user_bundle.account.key,
media_url=self.request.get("media_url"),
event_key=event_key)
if status == 'success':
# Send an update to the FUN slack
slack_sitevar = Sitevar.get_or_insert('slack.hookurls')
if slack_sitevar:
slack_url = slack_sitevar.contents.get('fun', '')
if slack_url:
message_body = "{0} ({1}) has suggested a video for <https://thebluealliance.com/event/{2}|{2}>: https://youtu.be/{3}.\nSee all suggestions at https://www.thebluealliance.com/suggest/event/media/review".format(
self.user_bundle.account.display_name,
self.user_bundle.account.email, event_key,
suggestion.contents['foreign_key'])
OutgoingNotificationHelper.send_slack_alert(
slack_url, message_body, [])
self.redirect('/suggest/event/media?event_key=%s&status=%s' %
(event_key, status))
def createSuggestion(self):
status = SuggestionCreator.createTeamMediaSuggestion(self.account.key,
'http://imgur.com/foobar',
'frc1124',
2016)
self.assertEqual(status[0], 'success')
return Suggestion.query().fetch(keys_only=True)[0].id()
def createSuggestion(self):
from helpers.suggestions.suggestion_creator import SuggestionCreator
status = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, 'Test Event', '2016-10-12', '2016-10-13',
'http://foo.bar.com', 'Venue Name', '123 Fake St', 'New York',
'NY', 'USA')
self.assertEqual(status[0], 'success')
return Suggestion.query().fetch(keys_only=True)[0].id()
def createDesignSuggestion(self):
status = SuggestionCreator.createTeamMediaSuggestion(
self.account.key,
'https://grabcad.com/library/2016-148-robowranglers-1', 'frc1124',
'2016')
self.assertEqual(status[0], 'success')
return Suggestion.render_media_key_name(
'2016', 'team', 'frc1124', 'grabcad', '2016-148-robowranglers-1')
def testMediaExists(self):
media_id = Media.render_key_name(MediaType.IMGUR, 'ruRAxDm')
Media.get_or_insert(media_id,
media_type_enum=MediaType.IMGUR,
foreign_key='ruRAxDm',
references=[ndb.Key(Team, 'frc1124')]).put()
status, _ = SuggestionCreator.createTeamMediaSuggestion(
self.account.key, "http://imgur.com/ruRAxDm", "frc1124", "2016")
self.assertEqual(status, 'media_exists')
def testNoRole(self):
event = Event(id="2016test", name="Test Event", event_short="Test Event", year=2016, event_type_enum=EventType.OFFSEASON)
event.put()
status = SuggestionCreator.createApiWriteSuggestion(
self.account.key,
"2016test",
"",
[1, 2, 3])
self.assertEqual(status, 'no_affiliation')
def test_no_role(self):
event = Event(id="2016test", name="Test Event", event_short="Test Event", year=2016, event_type_enum=EventType.OFFSEASON)
event.put()
status = SuggestionCreator.createApiWriteSuggestion(
self.account.key,
"2016test",
"",
[1, 2, 3])
self.assertEqual(status, 'no_affiliation')
def get(self, year):
df = DatafeedFMSAPI('v2.0')
first_events, _ = df.getSyncEnabledOffseasonEvents(year)
linked_events, maybed_linked_events, new_events = \
OffseasonEventHelper.categorize_offseasons(int(year), first_events)
events_to_update = []
events_to_put = []
# for all events with a first_code linked, ensure official=True
logging.info("Found {} already linked events".format(
len(linked_events)))
for tba, first in linked_events:
if tba.first_code != first.event_short or not tba.official:
tba.first_code = first.event_short
tba.official = True
events_to_put.append(tba)
events_to_update.append(tba)
# for all events that we can maybe link, also do that
logging.info("Auto-linking {} probably events".format(
len(maybed_linked_events)))
for tba, first in maybed_linked_events:
tba.first_code = first.event_short
tba.official = True
events_to_put.append(tba)
events_to_update.append(tba)
logging.info("Found {} events to put".format(len(events_to_put)))
if events_to_put:
EventManipulator.createOrUpdate(events_to_put)
# Enqueue details updates for these events
logging.info("Found {} events to update".format(len(events_to_update)))
for event in events_to_update:
taskqueue.add(queue_name='datafeed',
target='backend-tasks',
url='/backend-tasks/get/event_details/' +
event.key_name,
method='GET')
# Event we don't have anything for... Create suggestions
logging.info("Found {} new events to link".format(len(new_events)))
SuggestionCreator.createDummyOffseasonSuggestions(new_events)
def post(self):
self._require_registration()
match_key = self.request.get("match_key")
youtube_url = self.request.get("youtube_url")
youtube_id = YouTubeVideoHelper.parse_id_from_url(youtube_url)
status = SuggestionCreator.createMatchVideoYouTubeSuggestion(self.user_bundle.account.key, youtube_id, match_key)
self.redirect('/suggest/match/video?match_key={}&status={}'.format(match_key, status))
def get(self, year):
df = DatafeedFMSAPI('v2.0')
first_events, _ = df.getSyncEnabledOffseasonEvents(year)
linked_events, maybed_linked_events, new_events = \
OffseasonEventHelper.categorize_offseasons(int(year), first_events)
events_to_update = []
events_to_put = []
# for all events with a first_code linked, ensure official=True
logging.info("Found {} already linked events".format(len(linked_events)))
for tba, first in linked_events:
if tba.first_code != first.event_short or not tba.official:
tba.first_code = first.event_short
tba.official = True
events_to_put.append(tba)
events_to_update.append(tba)
# for all events that we can maybe link, also do that
logging.info("Auto-linking {} probably events".format(len(maybed_linked_events)))
for tba, first in maybed_linked_events:
tba.first_code = first.event_short
tba.official = True
events_to_put.append(tba)
events_to_update.append(tba)
logging.info("Found {} events to put".format(len(events_to_put)))
if events_to_put:
EventManipulator.createOrUpdate(events_to_put)
# Enqueue details updates for these events
logging.info("Found {} events to update".format(len(events_to_update)))
for event in events_to_update:
taskqueue.add(
queue_name='datafeed',
target='backend-tasks',
url='/backend-tasks/get/event_details/'+event.key_name,
method='GET'
)
# Event we don't have anything for... Create suggestions
logging.info("Found {} new events to link".format(len(new_events)))
SuggestionCreator.createDummyOffseasonSuggestions(new_events)
def testOutOfOrderDates(self):
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"Test Event",
"2016-5-4",
"2016-5-2",
"http://foo.bar.com",
"123 Fake Street, New York, NY")
self.assertEqual(status, 'validation_failure')
self.assertTrue('end_date' in failures)
def testWebcastAlreadyExists(self):
event = Event(id="2016test", name="Test Event", event_short="Test Event", year=2016,
event_type_enum=EventType.OFFSEASON,
webcast_json="[{\"type\": \"twitch\", \"channel\": \"frcgamesense\"}]")
event.put()
status = SuggestionCreator.createEventWebcastSuggestion(
self.account.key,
"http://twitch.tv/frcgamesense",
"2016test")
self.assertEqual(status, 'webcast_exists')
def test_out_of_order_dates(self):
status, failures = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key,
"Test Event",
"2016-5-4",
"2016-5-2",
"http://foo.bar.com",
"The Venue",
"123 Fake Street", "New York", "NY", "USA")
self.assertEqual(status, 'validation_failure')
self.assertTrue('end_date' in failures)
def test_media_exists(self):
media_id = Media.render_key_name(MediaType.YOUTUBE_VIDEO, 'H-54KMwMKY0')
Media.get_or_insert(
media_id,
media_type_enum=MediaType.YOUTUBE_VIDEO,
foreign_key='H-54KMwMKY0',
references=[ndb.Key(Event, '2016nyny')]).put()
status, _ = SuggestionCreator.createEventMediaSuggestion(
self.account.key,
"https://www.youtube.com/watch?v=H-54KMwMKY0",
"2016nyny")
self.assertEqual(status, 'media_exists')
def post(self):
self._require_login()
team_key = self.request.get("team_key")
year_str = self.request.get("year")
status = SuggestionCreator.createTeamMediaSuggestion(
author_account_key=self.user_bundle.account.key,
media_url=self.request.get("media_url"),
team_key=team_key,
year_str=year_str)
self.redirect('/suggest/team/media?team_key=%s&year=%s&status=%s' % (team_key, year_str, status))
def testMediaExists(self):
media_id = Media.render_key_name(MediaType.IMGUR, 'ruRAxDm')
Media.get_or_insert(
media_id,
media_type_enum=MediaType.IMGUR,
foreign_key='ruRAxDm',
references=[ndb.Key(Team, 'frc1124')]).put()
status = SuggestionCreator.createTeamMediaSuggestion(
self.account.key,
"http://imgur.com/ruRAxDm",
"frc1124",
"2016")
self.assertEqual(status, 'media_exists')
def post(self):
self._require_registration()
team_key = self.request.get("team_key")
status, suggestion = SuggestionCreator.createTeamMediaSuggestion(
author_account_key=self.user_bundle.account.key,
media_url=self.request.get("media_url"),
team_key=team_key,
year_str=None,
is_social=True)
self.redirect('/suggest/team/social_media?team_key=%s&status=%s' % (team_key, status))
