def get(self):
self._require_admin()
self.template_values['memcache_stats'] = memcache.get_stats()
self.template_values['databasequery_stats'] = {
'hits':
sum(
filter(None, [
memcache.get(key)
for key in DatabaseQuery.DATABASE_HITS_MEMCACHE_KEYS
])),
'misses':
sum(
filter(None, [
memcache.get(key)
for key in DatabaseQuery.DATABASE_MISSES_MEMCACHE_KEYS
]))
}
# Gets the 5 recently created users
users = Account.query().order(-Account.created).fetch(5)
self.template_values['users'] = users
# Retrieves the number of pending suggestions
video_suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").count()
self.template_values['video_suggestions'] = video_suggestions
webcast_suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "event").count()
self.template_values['webcast_suggestions'] = webcast_suggestions
media_suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "media").count()
self.template_values['media_suggestions'] = media_suggestions
# version info
try:
fname = os.path.join(os.path.dirname(__file__),
'../../version_info.json')
with open(fname, 'r') as f:
data = json.loads(f.read().replace('\r\n', '\n'))
self.template_values['git_branch_name'] = data['git_branch_name']
self.template_values['build_time'] = data['build_time']
commit_parts = re.split("[\n]+", data['git_last_commit'])
self.template_values['commit_hash'] = commit_parts[0].split(" ")
self.template_values['commit_author'] = commit_parts[1]
self.template_values['commit_date'] = commit_parts[2]
self.template_values['commit_msg'] = commit_parts[3]
except Exception, e:
logging.warning("version_info.json parsing failed: %s" % e)
pass
def get(self):
redirect = self.request.get('redirect')
if redirect:
self._require_login(redirect)
else:
self._require_login('/account')
# Redirects to registration page if account not registered
self._require_registration('/account/register')
push_sitevar = Sitevar.get_by_id('notifications.enable')
if push_sitevar is None or not push_sitevar.values_json == "true":
ping_enabled = "disabled"
else:
ping_enabled = ""
# Compute myTBA statistics
user = self.user_bundle.account.key
num_favorites = Favorite.query(ancestor=user).count()
num_subscriptions = Subscription.query(ancestor=user).count()
# Compute suggestion statistics
submissions_pending = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_PENDING,
Suggestion.author == user).count()
submissions_accepted = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_ACCEPTED,
Suggestion.author == user).count()
# Suggestion review statistics
review_permissions = False
num_reviewed = 0
total_pending = 0
if AccountPermissions.MUTATE_DATA in self.user_bundle.account.permissions:
review_permissions = True
num_reviewed = Suggestion.query(
Suggestion.reviewer == user).count()
total_pending = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_PENDING).count()
self.template_values['status'] = self.request.get('status')
self.template_values[
'webhook_verification_success'] = self.request.get(
'webhook_verification_success')
self.template_values['ping_enabled'] = ping_enabled
self.template_values['num_favorites'] = num_favorites
self.template_values['num_subscriptions'] = num_subscriptions
self.template_values['submissions_pending'] = submissions_pending
self.template_values['submissions_accepted'] = submissions_accepted
self.template_values['review_permissions'] = review_permissions
self.template_values['num_reviewed'] = num_reviewed
self.template_values['total_pending'] = total_pending
self.response.out.write(
jinja2_engine.render('account_overview.html',
self.template_values))
def get(self):
self._require_registration()
push_sitevar = Sitevar.get_by_id('notifications.enable')
if push_sitevar is None or not push_sitevar.values_json == "true":
ping_enabled = "disabled"
else:
ping_enabled = ""
# Compute myTBA statistics
user = self.user_bundle.account.key
num_favorites = Favorite.query(ancestor=user).count()
num_subscriptions = Subscription.query(ancestor=user).count()
# Compute suggestion statistics
submissions_pending = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_PENDING,
Suggestion.author == user).count()
submissions_accepted = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_ACCEPTED,
Suggestion.author == user).count()
# Suggestion review statistics
review_permissions = False
num_reviewed = 0
total_pending = 0
if AccountPermissions.REVIEW_MEDIA in self.user_bundle.account.permissions:
review_permissions = True
num_reviewed = Suggestion.query(
Suggestion.reviewer == user).count()
total_pending = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_PENDING).count()
# Fetch trusted API keys
trusted_keys = ApiAuthAccess.query(ApiAuthAccess.owner == user).fetch()
self.template_values['status'] = self.request.get('status')
self.template_values[
'webhook_verification_success'] = self.request.get(
'webhook_verification_success')
self.template_values['ping_enabled'] = ping_enabled
self.template_values['num_favorites'] = num_favorites
self.template_values['num_subscriptions'] = num_subscriptions
self.template_values['submissions_pending'] = submissions_pending
self.template_values['submissions_accepted'] = submissions_accepted
self.template_values['review_permissions'] = review_permissions
self.template_values['num_reviewed'] = num_reviewed
self.template_values['total_pending'] = total_pending
self.template_values['trusted_keys'] = trusted_keys
self.template_values['auth_type_names'] = AuthType.type_names
self.response.out.write(
jinja2_engine.render('account_overview.html',
self.template_values))
def get(self):
self._require_registration()
notifications_enabled = NotificationsEnable.notifications_enabled()
if not notifications_enabled:
ping_enabled = "disabled"
else:
ping_enabled = ""
# Compute myTBA statistics
user = self.user_bundle.account.key
num_favorites = Favorite.query(ancestor=user).count()
num_subscriptions = Subscription.query(ancestor=user).count()
# Compute suggestion statistics
submissions_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING, Suggestion.author==user).count()
submissions_accepted = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_ACCEPTED, Suggestion.author==user).count()
# Suggestion review statistics
review_permissions = False
num_reviewed = 0
total_pending = 0
if self.user_bundle.account.permissions:
review_permissions = True
num_reviewed = Suggestion.query(Suggestion.reviewer==user).count()
total_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING).count()
# Fetch trusted API keys
api_keys = ApiAuthAccess.query(ApiAuthAccess.owner == user).fetch()
write_keys = filter(lambda key: key.is_write_key, api_keys)
write_keys.sort(key=lambda key: key.event_list[0])
read_keys = filter(lambda key: key.is_read_key, api_keys)
self.template_values['status'] = self.request.get('status')
self.template_values['webhook_verification_success'] = self.request.get('webhook_verification_success')
self.template_values['ping_sent'] = self.request.get('ping_sent')
self.template_values['ping_enabled'] = ping_enabled
self.template_values['num_favorites'] = num_favorites
self.template_values['num_subscriptions'] = num_subscriptions
self.template_values['submissions_pending'] = submissions_pending
self.template_values['submissions_accepted'] = submissions_accepted
self.template_values['review_permissions'] = review_permissions
self.template_values['num_reviewed'] = num_reviewed
self.template_values['total_pending'] = total_pending
self.template_values['read_keys'] = read_keys
self.template_values['write_keys'] = write_keys
self.template_values['auth_write_type_names'] = AuthType.write_type_names
self.response.out.write(jinja2_engine.render('account_overview.html', self.template_values))
def get(self):
self._require_registration()
push_sitevar = Sitevar.get_by_id("notifications.enable")
if push_sitevar is None or not push_sitevar.values_json == "true":
ping_enabled = "disabled"
else:
ping_enabled = ""
# Compute myTBA statistics
user = self.user_bundle.account.key
num_favorites = Favorite.query(ancestor=user).count()
num_subscriptions = Subscription.query(ancestor=user).count()
# Compute suggestion statistics
submissions_pending = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_PENDING, Suggestion.author == user
).count()
submissions_accepted = Suggestion.query(
Suggestion.review_state == Suggestion.REVIEW_ACCEPTED, Suggestion.author == user
).count()
# Suggestion review statistics
review_permissions = False
num_reviewed = 0
total_pending = 0
if self.user_bundle.account.permissions:
review_permissions = True
num_reviewed = Suggestion.query(Suggestion.reviewer == user).count()
total_pending = Suggestion.query(Suggestion.review_state == Suggestion.REVIEW_PENDING).count()
# Fetch trusted API keys
trusted_keys = ApiAuthAccess.query(ApiAuthAccess.owner == user).fetch()
self.template_values["status"] = self.request.get("status")
self.template_values["webhook_verification_success"] = self.request.get("webhook_verification_success")
self.template_values["ping_enabled"] = ping_enabled
self.template_values["num_favorites"] = num_favorites
self.template_values["num_subscriptions"] = num_subscriptions
self.template_values["submissions_pending"] = submissions_pending
self.template_values["submissions_accepted"] = submissions_accepted
self.template_values["review_permissions"] = review_permissions
self.template_values["num_reviewed"] = num_reviewed
self.template_values["total_pending"] = total_pending
self.template_values["trusted_keys"] = trusted_keys
self.template_values["auth_type_names"] = AuthType.type_names
self.response.out.write(jinja2_engine.render("account_overview.html", self.template_values))
def get(self):
self._require_registration()
push_sitevar = Sitevar.get_by_id('notifications.enable')
if push_sitevar is None or not push_sitevar.values_json == "true":
ping_enabled = "disabled"
else:
ping_enabled = ""
# Compute myTBA statistics
user = self.user_bundle.account.key
num_favorites = Favorite.query(ancestor=user).count()
num_subscriptions = Subscription.query(ancestor=user).count()
# Compute suggestion statistics
submissions_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING, Suggestion.author==user).count()
submissions_accepted = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_ACCEPTED, Suggestion.author==user).count()
# Suggestion review statistics
review_permissions = False
num_reviewed = 0
total_pending = 0
if self.user_bundle.account.permissions:
review_permissions = True
num_reviewed = Suggestion.query(Suggestion.reviewer==user).count()
total_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING).count()
# Fetch trusted API keys
api_keys = ApiAuthAccess.query(ApiAuthAccess.owner == user).fetch()
write_keys = filter(lambda key: key.is_write_key, api_keys)
read_keys = filter(lambda key: key.is_read_key, api_keys)
self.template_values['status'] = self.request.get('status')
self.template_values['webhook_verification_success'] = self.request.get('webhook_verification_success')
self.template_values['ping_sent'] = self.request.get('ping_sent')
self.template_values['ping_enabled'] = ping_enabled
self.template_values['num_favorites'] = num_favorites
self.template_values['num_subscriptions'] = num_subscriptions
self.template_values['submissions_pending'] = submissions_pending
self.template_values['submissions_accepted'] = submissions_accepted
self.template_values['review_permissions'] = review_permissions
self.template_values['num_reviewed'] = num_reviewed
self.template_values['total_pending'] = total_pending
self.template_values['read_keys'] = read_keys
self.template_values['write_keys'] = write_keys
self.template_values['auth_write_type_names'] = AuthType.write_type_names
self.response.out.write(jinja2_engine.render('account_overview.html', self.template_values))
def get(self):
self._require_admin()
self.template_values['memcache_stats'] = memcache.get_stats()
self.template_values['databasequery_stats'] = {
'hits': sum(filter(None, [memcache.get(key) for key in DatabaseQuery.DATABASE_HITS_MEMCACHE_KEYS])),
'misses': sum(filter(None, [memcache.get(key) for key in DatabaseQuery.DATABASE_MISSES_MEMCACHE_KEYS]))
}
# Gets the 5 recently created users
users = Account.query().order(-Account.created).fetch(5)
self.template_values['users'] = users
# Retrieves the number of pending suggestions
video_suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").count()
self.template_values['video_suggestions'] = video_suggestions
webcast_suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "event").count()
self.template_values['webcast_suggestions'] = webcast_suggestions
media_suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "media").count()
self.template_values['media_suggestions'] = media_suggestions
# version info
try:
fname = os.path.join(os.path.dirname(__file__), '../../version_info.json')
with open(fname, 'r') as f:
data = json.loads(f.read().replace('\r\n', '\n'))
self.template_values['git_branch_name'] = data['git_branch_name']
self.template_values['build_time'] = data['build_time']
commit_parts = re.split("[\n]+", data['git_last_commit'])
self.template_values['commit_hash'] = commit_parts[0].split(" ")
self.template_values['commit_author'] = commit_parts[1]
self.template_values['commit_date'] = commit_parts[2]
self.template_values['commit_msg'] = commit_parts[3]
except Exception, e:
logging.warning("version_info.json parsing failed: %s" % e)
pass
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "offseason-event")
year = datetime.now().year
year_events_future = EventListQuery(year).fetch_async()
last_year_events_future = EventListQuery(year - 1).fetch_async()
events_and_ids = [self._create_candidate_event(suggestion) for suggestion in suggestions]
year_events = year_events_future.get_result()
year_offseason_events = [e for e in year_events if e.event_type_enum == EventType.OFFSEASON]
last_year_events = last_year_events_future.get_result()
last_year_offseason_events = [e for e in last_year_events if e.event_type_enum == EventType.OFFSEASON]
similar_events = [self._get_similar_events(event[1], year_offseason_events) for event in events_and_ids]
similar_last_year = [self._get_similar_events(event[1], last_year_offseason_events) for event in events_and_ids]
self.template_values.update({
'success': self.request.get("success"),
'event_key': self.request.get("event_key"),
'events_and_ids': events_and_ids,
'similar_events': similar_events,
'similar_last_year': similar_last_year,
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_offseason_event_review_list.html', self.template_values))
def get(self):
self._require_admin()
self.template_values['memcache_stats'] = memcache.get_stats()
# Gets the 5 recently created users
users = Account.query().order(-Account.created).fetch(5)
self.template_values['users'] = users
# Retrieves the number of pending suggestions
video_suggestions = Suggestion.query().filter(Suggestion.review_state == Suggestion.REVIEW_PENDING).count()
self.template_values['video_suggestions'] = video_suggestions
# version info
try:
fname = os.path.join(os.path.dirname(__file__), '../../version_info.json')
with open(fname, 'r') as f:
data = json.loads(f.read().replace('\r\n', '\n'))
self.template_values['git_branch_name'] = data['git_branch_name']
self.template_values['build_time'] = data['build_time']
commit_parts = re.split("[\n]+", data['git_last_commit'])
self.template_values['commit_hash'] = commit_parts[0].split(" ")
self.template_values['commit_author'] = commit_parts[1]
self.template_values['commit_date'] = commit_parts[2]
self.template_values['commit_msg'] = commit_parts[3]
except Exception, e:
logging.warning("version_info.json parsing failed: %s" % e)
pass
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "offseason-event")
year = datetime.now().year
year_events_future = EventListQuery(year).fetch_async()
last_year_events_future = EventListQuery(year - 1).fetch_async()
events_and_ids = [self._create_candidate_event(suggestion) for suggestion in suggestions]
year_events = year_events_future.get_result()
year_offseason_events = [e for e in year_events if e.event_type_enum == EventType.OFFSEASON]
last_year_events = last_year_events_future.get_result()
last_year_offseason_events = [e for e in last_year_events if e.event_type_enum == EventType.OFFSEASON]
similar_events = [self._get_similar_events(event[1], year_offseason_events) for event in events_and_ids]
similar_last_year = [self._get_similar_events(event[1], last_year_offseason_events) for event in events_and_ids]
self.template_values.update({
'success': self.request.get("success"),
'event_key': self.request.get("event_key"),
'events_and_ids': events_and_ids,
'similar_events': similar_events,
'similar_last_year': similar_last_year,
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_offseason_event_review_list.html', self.template_values))
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 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 get(self):
super(SuggestSocialMediaReviewController, self).get()
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "social-media").fetch(limit=50)
reference_keys = []
for suggestion in suggestions:
reference_key = suggestion.contents['reference_key']
reference = Media.create_reference(
suggestion.contents['reference_type'], reference_key)
reference_keys.append(reference)
reference_futures = ndb.get_multi_async(reference_keys)
references = map(lambda r: r.get_result(), reference_futures)
suggestions_and_references = zip(suggestions, references)
self.template_values.update({
"suggestions_and_references":
suggestions_and_references,
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_team_social_review.html',
self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "event")
suggestions_by_event_key = {}
for suggestion in suggestions:
if 'webcast_dict' in suggestion.contents:
suggestion.webcast_template = 'webcast/{}.html'.format(suggestion.contents['webcast_dict']['type'])
suggestions_by_event_key.setdefault(suggestion.target_key, []).append(suggestion)
suggestion_sets = []
for event_key, suggestions in suggestions_by_event_key.items():
suggestion_sets.append({
"event": Event.get_by_id(event_key),
"suggestions": suggestions
})
self.template_values.update({
"event_key": self.request.get("event_key"),
"success": self.request.get("success"),
"suggestion_sets": suggestion_sets
})
path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_event_webcast_review_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
super(SuggestDesignsReviewController, self).get()
if self.request.get('action') and self.request.get('id'):
# Fast-path review
self._fastpath_review()
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "robot").fetch(limit=50)
reference_keys = []
for suggestion in suggestions:
reference_key = suggestion.contents['reference_key']
reference = Media.create_reference(
suggestion.contents['reference_type'],
reference_key)
reference_keys.append(reference)
reference_futures = ndb.get_multi_async(reference_keys)
references = map(lambda r: r.get_result(), reference_futures)
suggestions_and_references = zip(suggestions, references)
self.template_values.update({
"suggestions_and_references": suggestions_and_references,
})
self.response.out.write(jinja2_engine.render('suggestions/suggest_designs_review.html', self.template_values))
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 get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "event_media").fetch(limit=50)
# Quick and dirty way to group images together
suggestions = sorted(suggestions, key=lambda x: 0 if x.contents['media_type_enum'] in MediaType.image_types else 1)
reference_keys = []
for suggestion in suggestions:
reference_key = suggestion.contents['reference_key']
reference = Media.create_reference(
suggestion.contents['reference_type'],
reference_key)
reference_keys.append(reference)
if 'details_json' in suggestion.contents:
suggestion.details = json.loads(suggestion.contents['details_json'])
if 'image_partial' in suggestion.details:
suggestion.details['thumbnail'] = suggestion.details['image_partial'].replace('_l', '_m')
reference_futures = ndb.get_multi_async(reference_keys)
references = map(lambda r: r.get_result(), reference_futures)
suggestions_and_references = zip(suggestions, references)
self.template_values.update({
"suggestions_and_references": suggestions_and_references,
})
self.response.out.write(jinja2_engine.render('suggestions/suggest_event_media_review_list.html', self.template_values))
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 get(self):
if self.request.get('action') and self.request.get('id'):
# Fast-path review
self._fastpath_review()
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "robot").fetch(limit=50)
reference_keys = []
for suggestion in suggestions:
reference_key = suggestion.contents['reference_key']
reference = Media.create_reference(
suggestion.contents['reference_type'], reference_key)
reference_keys.append(reference)
reference_futures = ndb.get_multi_async(reference_keys)
references = map(lambda r: r.get_result(), reference_futures)
suggestions_and_references = zip(suggestions, references)
self.template_values.update({
"suggestions_and_references":
suggestions_and_references,
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_designs_review.html',
self.template_values))
def get(self):
self._require_admin()
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "media")
reference_keys = []
for suggestion in suggestions:
reference_keys.append(
Media.create_reference(suggestion.contents['reference_type'],
suggestion.contents['reference_key']))
if 'details_json' in suggestion.contents:
suggestion.details = json.loads(
suggestion.contents['details_json'])
suggestion.details['thumbnail'] = suggestion.details[
'image_partial'].replace('_l', '_m')
reference_futures = ndb.get_multi_async(reference_keys)
references = map(lambda r: r.get_result(), reference_futures)
suggestions_and_references = zip(suggestions, references)
self.template_values.update({
"suggestions_and_references":
suggestions_and_references,
})
path = os.path.join(
os.path.dirname(__file__),
'../../../templates/admin/media_suggestion_list.html')
self.response.out.write(template.render(path, self.template_values))
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 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 get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "event")
suggestions_by_event_key = {}
for suggestion in suggestions:
if 'webcast_dict' in suggestion.contents:
suggestion.webcast_template = 'webcast/{}.html'.format(suggestion.contents['webcast_dict']['type'])
suggestions_by_event_key.setdefault(suggestion.target_key, []).append(suggestion)
suggestion_sets = []
for event_key, suggestions in suggestions_by_event_key.items():
suggestion_sets.append({
"event": Event.get_by_id(event_key),
"suggestions": suggestions
})
self.template_values.update({
"event_key": self.request.get("event_key"),
"success": self.request.get("success"),
"suggestion_sets": suggestion_sets
})
path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_event_webcast_review_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "media")
reference_keys = []
for suggestion in suggestions:
reference_keys.append(Media.create_reference(
suggestion.contents['reference_type'],
suggestion.contents['reference_key']))
if 'details_json' in suggestion.contents:
suggestion.details = json.loads(suggestion.contents['details_json'])
if 'image_partial' in suggestion.details:
suggestion.details['thumbnail'] = suggestion.details['image_partial'].replace('_l', '_m')
reference_futures = ndb.get_multi_async(reference_keys)
references = map(lambda r: r.get_result(), reference_futures)
suggestions_and_references = zip(suggestions, references)
self.template_values.update({
"suggestions_and_references": suggestions_and_references,
})
path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_team_media_review_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
super(SuggestTeamMediaReviewController, self).get()
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "media").fetch(limit=50)
# Quick and dirty way to group images together
suggestions = sorted(
suggestions,
key=lambda x: 0
if x.contents['media_type_enum'] in MediaType.image_types else 1)
reference_keys = []
existing_preferred_keys_futures = []
for suggestion in suggestions:
reference_key = suggestion.contents['reference_key']
reference = Media.create_reference(
suggestion.contents['reference_type'], reference_key)
reference_keys.append(reference)
if 'details_json' in suggestion.contents:
suggestion.details = json.loads(
suggestion.contents['details_json'])
if 'image_partial' in suggestion.details:
suggestion.details['thumbnail'] = suggestion.details[
'image_partial'].replace('_l', '_m')
# Find existing preferred images
existing_preferred_keys_futures.append(
Media.query(
Media.media_type_enum.IN(MediaType.image_types),
Media.references == reference,
Media.preferred_references == reference,
Media.year == suggestion.contents['year'],
).fetch_async(keys_only=True))
reference_futures = ndb.get_multi_async(reference_keys)
existing_preferred_futures = map(
lambda x: ndb.get_multi_async(x.get_result()),
existing_preferred_keys_futures)
references = map(lambda r: r.get_result(), reference_futures)
existing_preferred = map(lambda l: map(lambda x: x.get_result(), l),
existing_preferred_futures)
suggestions_and_references_and_preferred = zip(suggestions, references,
existing_preferred)
self.template_values.update({
"suggestions_and_references_and_preferred":
suggestions_and_references_and_preferred,
"max_preferred":
Media.MAX_PREFERRED,
})
self.response.out.write(
jinja2_engine.render(
'suggestions/suggest_team_media_review_list.html',
self.template_values))
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 get(self):
redirect = self.request.get('redirect')
if redirect:
self._require_login(redirect)
else:
self._require_login('/account')
# Redirects to registration page if account not registered
self._require_registration('/account/register')
push_sitevar = Sitevar.get_by_id('notifications.enable')
if push_sitevar is None or not push_sitevar.values_json == "true":
ping_enabled = "disabled"
else:
ping_enabled = ""
# Compute myTBA statistics
user = self.user_bundle.account.key
num_favorites = Favorite.query(ancestor=user).count()
num_subscriptions = Subscription.query(ancestor=user).count()
# Compute suggestion statistics
submissions_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING, Suggestion.author==user).count()
submissions_accepted = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_ACCEPTED, Suggestion.author==user).count()
# Suggestion review statistics
review_permissions = False
num_reviewed = 0
total_pending = 0
if AccountPermissions.MUTATE_DATA in self.user_bundle.account.permissions:
review_permissions = True
num_reviewed = Suggestion.query(Suggestion.reviewer==user).count()
total_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING).count()
self.template_values['status'] = self.request.get('status')
self.template_values['webhook_verification_success'] = self.request.get('webhook_verification_success')
self.template_values['ping_enabled'] = ping_enabled
self.template_values['num_favorites'] = num_favorites
self.template_values['num_subscriptions'] = num_subscriptions
self.template_values['submissions_pending'] = submissions_pending
self.template_values['submissions_accepted'] = submissions_accepted
self.template_values['review_permissions'] = review_permissions
self.template_values['num_reviewed'] = num_reviewed
self.template_values['total_pending'] = total_pending
self.response.out.write(jinja2_engine.render('account_overview.html', self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
self.template_values.update({
"suggestions": suggestions,
})
path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_match_video_review_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
self.template_values.update({
"suggestions": suggestions,
})
path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_match_video_review_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
self._require_admin()
suggestions = Suggestion.query().filter(Suggestion.review_state == Suggestion.REVIEW_PENDING)
self.template_values.update({
"suggestions": suggestions,
})
path = os.path.join(os.path.dirname(__file__), '../../../templates/admin/suggestion_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
self._require_admin()
self.template_values['memcache_stats'] = memcache.get_stats()
self.template_values['databasequery_stats'] = {
'hits':
sum(
filter(None, [
memcache.get(key)
for key in DatabaseQuery.DATABASE_HITS_MEMCACHE_KEYS
])),
'misses':
sum(
filter(None, [
memcache.get(key)
for key in DatabaseQuery.DATABASE_MISSES_MEMCACHE_KEYS
]))
}
# Gets the 5 recently created users
users = Account.query().order(-Account.created).fetch(5)
self.template_values['users'] = users
self.template_values['suggestions_count'] = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).count()
# Continuous deployment info
status_sitevar = Sitevar.get_by_id('apistatus')
self.template_values[
'contbuild_enabled'] = status_sitevar.contents.get(
'contbuild_enabled') if status_sitevar else None
# version info
try:
fname = os.path.join(os.path.dirname(__file__),
'../../version_info.json')
with open(fname, 'r') as f:
data = json.loads(f.read().replace('\r\n', '\n'))
self.template_values['git_branch_name'] = data['git_branch_name']
self.template_values['build_time'] = data['build_time']
self.template_values['build_number'] = data.get('build_number')
commit_parts = re.split("[\n]+", data['git_last_commit'])
self.template_values['commit_hash'] = commit_parts[0].split(" ")
self.template_values['commit_author'] = commit_parts[1]
self.template_values['commit_date'] = commit_parts[2]
self.template_values['commit_msg'] = commit_parts[3]
except Exception, e:
logging.warning("version_info.json parsing failed: %s" % e)
pass
def get(self):
suggestions = (
Suggestion.query()
.filter(Suggestion.review_state == Suggestion.REVIEW_PENDING)
.filter(Suggestion.target_model == "media")
.fetch(limit=50)
)
# Quick and dirty way to group images together
suggestions = sorted(
suggestions, key=lambda x: 0 if x.contents["media_type_enum"] in MediaType.image_types else 1
)
reference_keys = []
existing_preferred_keys_futures = []
for suggestion in suggestions:
reference_key = suggestion.contents["reference_key"]
reference = Media.create_reference(suggestion.contents["reference_type"], reference_key)
reference_keys.append(reference)
if "details_json" in suggestion.contents:
suggestion.details = json.loads(suggestion.contents["details_json"])
if "image_partial" in suggestion.details:
suggestion.details["thumbnail"] = suggestion.details["image_partial"].replace("_l", "_m")
# Find existing preferred images
existing_preferred_keys_futures.append(
Media.query(
Media.media_type_enum.IN(MediaType.image_types),
Media.references == reference,
Media.preferred_references == reference,
Media.year == suggestion.contents["year"],
).fetch_async(keys_only=True)
)
reference_futures = ndb.get_multi_async(reference_keys)
existing_preferred_futures = map(lambda x: ndb.get_multi_async(x.get_result()), existing_preferred_keys_futures)
references = map(lambda r: r.get_result(), reference_futures)
existing_preferred = map(lambda l: map(lambda x: x.get_result(), l), existing_preferred_futures)
suggestions_and_references_and_preferred = zip(suggestions, references, existing_preferred)
self.template_values.update(
{
"suggestions_and_references_and_preferred": suggestions_and_references_and_preferred,
"max_preferred": Media.MAX_PREFERRED,
}
)
self.response.out.write(
jinja2_engine.render("suggestions/suggest_team_media_review_list.html", self.template_values)
)
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "offseason-event")
events_and_ids = [self._create_candidate_event(suggestion) for suggestion in suggestions]
self.template_values.update({
'success': self.request.get("success"),
'event_key': self.request.get("event_key"),
'events_and_ids': events_and_ids,
})
self.response.out.write(
jinja2_engine.render('suggestions/suggest_offseason_event_review_list.html', self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "api_auth_access").fetch()
suggestions = [self._ids_and_events(suggestion) for suggestion in suggestions]
self.template_values.update({
'success': self.request.get("success"),
'suggestions': suggestions,
'auth_names': AuthType.type_names,
})
self.response.out.write(
jinja2_engine.render('suggest_apiwrite_review_list.html', self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "api_auth_access").fetch()
suggestions = [self._ids_and_events(suggestion) for suggestion in suggestions]
self.template_values.update({
'success': self.request.get("success"),
'suggestions': suggestions,
'auth_names': AuthType.type_names,
})
self.response.out.write(
jinja2_engine.render('suggest_apiwrite_review_list.html', self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
# Roughly sort by event and match for easier review
suggestions = sorted(suggestions, key=lambda s: s.target_key)
self.template_values.update({
"suggestions": suggestions,
})
self.response.out.write(jinja2_engine.render('suggestions/suggest_match_video_review_list.html', self.template_values))
def get(self):
self._require_admin()
suggestions = (
Suggestion.query()
.filter(Suggestion.review_state == Suggestion.REVIEW_PENDING)
.filter(Suggestion.target_model == "match")
)
self.template_values.update({"suggestions": suggestions})
path = os.path.join(os.path.dirname(__file__), "../../../templates/admin/match_video_suggestion_list.html")
self.response.out.write(template.render(path, self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "offseason-event")
events_and_ids = [self._create_candidate_event(suggestion) for suggestion in suggestions]
self.template_values.update({
'success': self.request.get("success"),
'event_key': self.request.get("event_key"),
'events_and_ids': events_and_ids,
})
self.response.out.write(
jinja2_engine.render('suggest_offseason_event_review_list.html', self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
# Roughly sort by event and match for easier review
suggestions = sorted(suggestions, key=lambda s: s.target_key)
self.template_values.update({
"suggestions": suggestions,
})
path = os.path.join(os.path.dirname(__file__), '../../templates/suggest_match_video_review_list.html')
self.response.out.write(template.render(path, self.template_values))
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 get(self):
self._require_admin()
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "event")
self.template_values.update({
"event_key": self.request.get("event_key"),
"success": self.request.get("success"),
"suggestions": suggestions,
})
path = os.path.join(os.path.dirname(__file__), '../../../templates/admin/event_webcast_suggestion_list.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
# Roughly sort by event and match for easier review
suggestions = sorted(suggestions, key=lambda s: s.target_key)
self.template_values.update({
"suggestions": suggestions,
})
self.response.out.write(
jinja2_engine.render(
'suggestions/suggest_match_video_review_list.html',
self.template_values))
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
# Roughly sort by event and match for easier review
suggestions = sorted(suggestions, key=lambda s: s.target_key)
event_futures = [Event.get_by_id_async(suggestion.target_key.split("_")[0]) for suggestion in suggestions]
events = [event_future.get_result() for event_future in event_futures]
self.template_values.update({
"suggestions_and_events": zip(suggestions, events),
})
self.response.out.write(jinja2_engine.render('suggestions/suggest_match_video_review_list.html', self.template_values))
def testSubmitWebcast(self):
self.loginUser()
form = self.getSuggestionForm('2016necmp')
form['webcast_url'] = 'https://twitch.tv/frcgamesense'
response = form.submit().follow()
self.assertEqual(response.status_int, 200)
request = response.request
self.assertEqual(request.GET.get('status'), 'success')
# Make sure the Suggestion gets created
suggestion = Suggestion.query().fetch()[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.review_state, Suggestion.REVIEW_PENDING)
self.assertEqual(suggestion.target_key, '2016necmp')
self.assertEqual(suggestion.contents['webcast_url'], 'https://twitch.tv/frcgamesense')
self.assertIsNotNone(suggestion.contents.get('webcast_dict'))
def testSubmitWebcast(self):
self.loginUser()
form = self.getSuggestionForm('2016necmp')
form['webcast_url'] = 'https://twitch.tv/frcgamesense'
response = form.submit().follow()
self.assertEqual(response.status_int, 200)
request = response.request
self.assertEqual(request.GET.get('status'), 'success')
# Make sure the Suggestion gets created
suggestion = Suggestion.query().fetch()[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.review_state, Suggestion.REVIEW_PENDING)
self.assertEqual(suggestion.target_key, '2016necmp')
self.assertEqual(suggestion.contents['webcast_url'],
'https://twitch.tv/frcgamesense')
self.assertIsNotNone(suggestion.contents.get('webcast_dict'))
def testUnknownUrlScheme(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')
suggestions = Suggestion.query().fetch()
self.assertIsNotNone(suggestions)
self.assertEqual(len(suggestions), 1)
suggestion = suggestions[0]
self.assertIsNotNone(suggestion)
self.assertIsNotNone(suggestion.contents)
self.assertIsNone(suggestion.contents.get('webcast_dict'))
self.assertEqual(suggestion.contents.get('webcast_url'), "http://myweb.site/somewebcast")
def testCreateSuggestion(self):
status, _ = SuggestionCreator.createOffseasonEventSuggestion(
self.account.key, "Test Event", "2016-5-1", "2016-5-2",
"http://foo.bar.com", "123 Fake Street, New York, NY")
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, New York, NY')
def testUndefinedAuthType(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",
"Event Organizer",
[1, 2, -1, -2]) # -1 and -2 should be filtered out
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['event_key'], "2016test")
self.assertEqual(suggestion.contents['affiliation'], "Event Organizer")
self.assertListEqual(suggestion.contents['auth_types'], [1, 2])
def test_official_event(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 test_undefined_auth_type(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",
"Event Organizer",
[1, 2, -1, -2]) # -1 and -2 should be filtered out
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['event_key'], "2016test")
self.assertEqual(suggestion.contents['affiliation'], "Event Organizer")
self.assertListEqual(suggestion.contents['auth_types'], [1, 2])
def testSuggestApiWrite(self):
self.loginUser()
form = self.getSuggestionForm()
form['event_key'] = '2016necmp'
form['role'] = 'Test Code'
form.get('auth_types', index=0).checked = True
form.get('auth_types', index=1).checked = True
response = form.submit().follow()
self.assertEqual(response.status_int, 200)
# Make sure the Suggestion gets created
suggestion = Suggestion.query().fetch()[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.review_state, Suggestion.REVIEW_PENDING)
self.assertEqual(suggestion.contents['event_key'], '2016necmp')
self.assertEqual(suggestion.contents['affiliation'], 'Test Code')
self.assertListEqual(suggestion.contents['auth_types'], [AuthType.MATCH_VIDEO, AuthType.EVENT_TEAMS])
# Ensure we show a success message on the page
request = response.request
self.assertEqual(request.GET.get('status'), 'success')
def get(self):
self._require_admin()
self.template_values['memcache_stats'] = memcache.get_stats()
self.template_values['databasequery_stats'] = {
'hits': sum(filter(None, [memcache.get(key) for key in DatabaseQuery.DATABASE_HITS_MEMCACHE_KEYS])),
'misses': sum(filter(None, [memcache.get(key) for key in DatabaseQuery.DATABASE_MISSES_MEMCACHE_KEYS]))
}
# Gets the 5 recently created users
users = Account.query().order(-Account.created).fetch(5)
self.template_values['users'] = users
self.template_values['suggestions_count'] = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).count()
# Continuous deployment info
status_sitevar = Sitevar.get_by_id('apistatus')
self.template_values['contbuild_enabled'] = status_sitevar.contents.get('contbuild_enabled') if status_sitevar else None
# version info
try:
fname = os.path.join(os.path.dirname(__file__), '../../version_info.json')
with open(fname, 'r') as f:
data = json.loads(f.read().replace('\r\n', '\n'))
self.template_values['git_branch_name'] = data['git_branch_name']
self.template_values['build_time'] = data['build_time']
self.template_values['build_number'] = data.get('build_number')
commit_parts = re.split("[\n]+", data['git_last_commit'])
self.template_values['commit_hash'] = commit_parts[0].split(" ")
self.template_values['commit_author'] = commit_parts[1]
self.template_values['commit_date'] = commit_parts[2]
self.template_values['commit_msg'] = commit_parts[3]
except Exception, e:
logging.warning("version_info.json parsing failed: %s" % e)
pass
def testSuggestApiWrite(self):
self.loginUser()
form = self.getSuggestionForm()
form['event_key'] = '2016necmp'
form['role'] = 'Test Code'
form.get('auth_types', index=0).checked = True
form.get('auth_types', index=1).checked = True
response = form.submit().follow()
self.assertEqual(response.status_int, 200)
# Make sure the Suggestion gets created
suggestion = Suggestion.query().fetch()[0]
self.assertIsNotNone(suggestion)
self.assertEqual(suggestion.review_state, Suggestion.REVIEW_PENDING)
self.assertEqual(suggestion.contents['event_key'], '2016necmp')
self.assertEqual(suggestion.contents['affiliation'], 'Test Code')
self.assertListEqual(suggestion.contents['auth_types'],
[AuthType.MATCH_VIDEO, AuthType.EVENT_TEAMS])
# Ensure we show a success message on the page
request = response.request
self.assertEqual(request.GET.get('status'), 'success')
def get(self):
suggestions = Suggestion.query().filter(
Suggestion.review_state == Suggestion.REVIEW_PENDING).filter(
Suggestion.target_model == "match").fetch(limit=50)
# Roughly sort by event and match for easier review
suggestions = sorted(suggestions, key=lambda s: s.target_key)
event_futures = [
Event.get_by_id_async(suggestion.target_key.split("_")[0])
for suggestion in suggestions
]
events = [event_future.get_result() for event_future in event_futures]
self.template_values.update({
"suggestions_and_events":
zip(suggestions, events),
})
self.response.out.write(
jinja2_engine.render(
'suggestions/suggest_match_video_review_list.html',
self.template_values))
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.createApiWriteSuggestion(
self.account_banned.key, "2016test", "Event Organizer", [1, 2, 3])
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['event_key'], "2016test")
self.assertEqual(suggestion.contents['affiliation'], "Event Organizer")
self.assertListEqual(suggestion.contents['auth_types'], [1, 2, 3])
self.assertEqual(suggestion.review_state,
Suggestion.REVIEW_AUTOREJECTED)
class SuggestionCreator(object):
@classmethod
def createTeamMediaSuggestion(cls,
author_account_key,
media_url,
team_key,
year_str,
private_details_json=None,
is_social=False,
default_preferred=False):
"""Create a Team Media Suggestion. Returns status (success, suggestion_exists, media_exists, bad_url)"""
media_dict = MediaParser.partial_media_dict_from_url(media_url)
if media_dict is not None:
if media_dict.get("is_social", False) != is_social:
return 'bad_url', None
existing_media = Media.get_by_id(
Media.render_key_name(media_dict['media_type_enum'],
media_dict['foreign_key']))
if existing_media is None or team_key not in [
reference.id() for reference in existing_media.references
]:
foreign_type = Media.SLUG_NAMES[media_dict['media_type_enum']]
suggestion_id = Suggestion.render_media_key_name(
year_str, 'team', team_key, foreign_type,
media_dict['foreign_key'])
suggestion = Suggestion.get_by_id(suggestion_id)
if not suggestion or suggestion.review_state != Suggestion.REVIEW_PENDING:
media_dict['year'] = int(year_str) if year_str else None
media_dict['reference_type'] = 'team'
media_dict['reference_key'] = team_key
media_dict['default_preferred'] = default_preferred
if private_details_json is not None:
media_dict[
'private_details_json'] = private_details_json
target_model = "media"
if media_dict.get("is_social", False):
target_model = "social-media"
if media_dict.get('media_type',
'') in MediaType.robot_types:
target_model = "robot"
if Event.validate_key_name(team_key):
target_model = 'event_media'
media_dict['reference_type'] = 'event'
suggestion = Suggestion(
id=suggestion_id,
author=author_account_key,
target_model=target_model,
)
suggestion.contents = media_dict
suggestion.put()
return 'success', suggestion
else:
return 'suggestion_exists', None
else:
return 'media_exists', None
else:
return 'bad_url', None
@classmethod
def createEventMediaSuggestion(cls,
author_account_key,
media_url,
event_key,
private_details_json=None):
"""Create an Event Media Suggestion. Returns status (success, suggestion_exists, media_exists, bad_url)"""
media_dict = MediaParser.partial_media_dict_from_url(media_url)
if media_dict is not None:
if media_dict[
'media_type_enum'] != MediaType.YOUTUBE_VIDEO and media_dict[
'media_type_enum'] != MediaType.INTERNET_ARCHIVE_VIDEO:
return 'bad_url', None
existing_media = Media.get_by_id(
Media.render_key_name(media_dict['media_type_enum'],
media_dict['foreign_key']))
if existing_media is None or event_key not in [
reference.id() for reference in existing_media.references
]:
foreign_type = Media.SLUG_NAMES[media_dict['media_type_enum']]
suggestion_id = Suggestion.render_media_key_name(
event_key[:4], 'event', event_key, foreign_type,
media_dict['foreign_key'])
suggestion = Suggestion.get_by_id(suggestion_id)
if not suggestion or suggestion.review_state != Suggestion.REVIEW_PENDING:
media_dict['year'] = event_key[:4]
media_dict['reference_type'] = 'event'
media_dict['reference_key'] = event_key
target_model = 'event_media'
if private_details_json is not None:
media_dict[
'private_details_json'] = private_details_json
suggestion = Suggestion(
id=suggestion_id,
author=author_account_key,
target_model=target_model,
)
suggestion.contents = media_dict
suggestion.put()
return 'success', suggestion
else:
return 'suggestion_exists', None
else:
return 'media_exists', None
else:
return 'bad_url', None
@classmethod
def createEventWebcastSuggestion(cls, author_account_key, webcast_url,
webcast_date, event_key):
"""Create a Event Webcast Suggestion. Returns status string"""
webcast_url = WebsiteHelper.format_url(webcast_url)
webcast_date = webcast_date.strip()
if webcast_date:
try:
datetime.strptime(webcast_date, "%Y-%m-%d")
except ValueError:
return 'invalid_date'
else:
webcast_date = None
try:
webcast_dict = WebcastParser.webcast_dict_from_url(webcast_url)
except Exception, e:
logging.exception(e)
webcast_dict = None
if webcast_dict is not None:
# Check if webcast already exists in event
event = Event.get_by_id(event_key)
if not event:
return 'bad_event'
if event.webcast and webcast_dict in event.webcast:
return 'webcast_exists'
else:
suggestion_id = Suggestion.render_webcast_key_name(
event_key, webcast_dict)
suggestion = Suggestion.get_by_id(suggestion_id)
# Check if suggestion exists
if not suggestion or suggestion.review_state != Suggestion.REVIEW_PENDING:
suggestion = Suggestion(
id=suggestion_id,
author=author_account_key,
target_model="event",
target_key=event_key,
)
suggestion.contents = {
"webcast_dict": webcast_dict,
"webcast_url": webcast_url,
"webcast_date": webcast_date
}
suggestion.put()
return 'success'
else:
return 'suggestion_exists'
else: # Can't parse URL -- could be an obscure webcast. Save URL and let a human deal with it.
contents = {
"webcast_url": webcast_url,
"webcast_date": webcast_date
}
# Check if suggestion exists
existing_suggestions = Suggestion.query(
Suggestion.target_model == 'event',
Suggestion.target_key == event_key).fetch()
for existing_suggestion in existing_suggestions:
if existing_suggestion.contents == contents:
return 'suggestion_exists'
suggestion = Suggestion(
author=author_account_key,
target_model="event",
target_key=event_key,
)
suggestion.contents = contents
suggestion.put()
return 'success'
