def test_subscription_search():
subscription = Subscription.search('google').first()
assert subscription is not None
assert subscription.name == 'Google Developers Blog'
subscription = Subscription.search('youtube').first()
assert subscription is not None
assert subscription.name == 'YouTube'
def test_user_subscriptions():
seed_user = User.get()
subscription = Subscription.get()
# Query checking if the subscription is in the user.
count_query = (UserSubscription.select()
.where(UserSubscription.user == seed_user,
UserSubscription.subscription == subscription))
# Unsubscribe first (regardless of subscription).
seed_user.unsubscribe(subscription)
assert count_query.count() == 0
assert subscription.num_subscribers() == 0
# Resubscribe.
seed_user.subscribe(subscription)
assert count_query.count() == 1
assert subscription.num_subscribers() == 1
# Resubscribe again.
seed_user.subscribe(subscription)
assert count_query.count() == 1
assert subscription.num_subscribers() == 1
# Unsubscribe again.
seed_user.unsubscribe(subscription)
assert count_query.count() == 0
assert subscription.num_subscribers() == 0
def get(self, event_key=None):
self._require_login()
self._require_registration()
if event_key is None:
events = EventHelper.getEventsWithinADay()
EventHelper.sort_events(events)
self.template_values['events'] = events
self.response.out.write(jinja2_engine.render('mytba_add_hot_matches_base.html', self.template_values))
return
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
subscriptions_future = Subscription.query(
Subscription.model_type==ModelType.MATCH,
Subscription.notification_types==NotificationType.UPCOMING_MATCH,
ancestor=self.user_bundle.account.key).fetch_async(projection=[Subscription.model_key])
matches = []
if event.matchstats and 'match_predictions' in event.matchstats:
match_predictions = event.matchstats['match_predictions']
max_hotness = 0
min_hotness = float('inf')
for match in event.matches:
if not match.has_been_played and match.key.id() in match_predictions:
prediction = match_predictions[match.key.id()]
red_score = prediction['red']['score']
blue_score = prediction['blue']['score']
if red_score > blue_score:
winner_score = red_score
loser_score = blue_score
else:
winner_score = blue_score
loser_score = red_score
hotness = winner_score + 2.0*loser_score # Favor close high scoring matches
max_hotness = max(max_hotness, hotness)
min_hotness = min(min_hotness, hotness)
match.hotness = hotness
matches.append(match)
existing_subscriptions = set()
for sub in subscriptions_future.get_result():
existing_subscriptions.add(sub.model_key)
hot_matches = []
for match in matches:
match.hotness = 100 * (match.hotness - min_hotness) / (max_hotness - min_hotness)
match.already_subscribed = match.key.id() in existing_subscriptions
hot_matches.append(match)
hot_matches = sorted(hot_matches, key=lambda match: -match.hotness)
matches_dict = {'qm': hot_matches[:25]}
self.template_values['event'] = event
self.template_values['matches'] = matches_dict
self.response.out.write(jinja2_engine.render('mytba_add_hot_matches.html', self.template_values))
def get(self, match_key):
self._require_login()
self._require_registration()
match = Match.get_by_id(match_key)
if not match:
self.abort(404)
user = self.user_bundle.account.key
favorite = Favorite.query(Favorite.model_key==match_key, Favorite.model_type==ModelType.MATCH, ancestor=user).get()
subscription = Subscription.query(Favorite.model_key==match_key, Favorite.model_type==ModelType.MATCH, ancestor=user).get()
if not favorite and not subscription: # New entry; default to being a favorite
is_favorite = True
else:
is_favorite = favorite is not None
enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_match_notifications]
self.template_values['match'] = match
self.template_values['is_favorite'] = is_favorite
self.template_values['subscription'] = subscription
self.template_values['enabled_notifications'] = enabled_notifications
self.response.out.write(jinja2_engine.render('mytba_match.html', self.template_values))
def get(self, team_number):
self._require_login()
self._require_registration()
team_key = 'frc{}'.format(team_number)
team = Team.get_by_id(team_key)
if not team:
self.abort(404)
user = self.user_bundle.account.key
favorite = Favorite.query(Favorite.model_key==team_key, Favorite.model_type==ModelType.TEAM, ancestor=user).get()
subscription = Subscription.query(Favorite.model_key==team_key, Favorite.model_type==ModelType.TEAM, ancestor=user).get()
if not favorite and not subscription: # New entry; default to being a favorite
is_favorite = True
else:
is_favorite = favorite is not None
enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_team_notifications]
self.template_values['team'] = team
self.template_values['is_favorite'] = is_favorite
self.template_values['subscription'] = subscription
self.template_values['enabled_notifications'] = enabled_notifications
self.response.out.write(jinja2_engine.render('mytba_team.html', self.template_values))
def add_subscription(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return BaseResponse(code=401, message="Unauthorized to add subscription")
userId = PushHelper.user_email_to_id(current_user.email())
modelKey = request.model_key
sub = Subscription.query( Subscription.user_id == userId, Subscription.model_key == modelKey).get()
if sub is None:
# Subscription doesn't exist, add it
Subscription( user_id = userId, model_key = modelKey, notification_types = PushHelper.notification_enums_from_string(request.notifications)).put()
if request.device_key:
# Send updates to user's other devices
GCMMessageHelper.send_subscription_update(userId, request.device_key)
return BaseResponse(code=200, message="Subscription added")
else:
if sub.notification_types == PushHelper.notification_enums_from_string(request.notifications):
# Subscription already exists. Don't add it again
return BaseResponse(code=304, message="Subscription already exists")
else:
# We're updating the settings
sub.notification_types = PushHelper.notification_enums_from_string(request.notifications)
sub.put()
if request.device_key:
# Send updates to user's other devices
GCMMessageHelper.send_subscription_update(userId, request.device_key)
return BaseResponse(code=200, message="Subscription updated")
def get_users_subscribed_to_event(cls, event, notification):
keys = []
keys.append(event.key_name)
keys.append("{}*".format(event.year))
users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch()
output = []
for user in users:
output.append(user.user_id)
return output
def remove_subscription(cls, userId, modelKey, device_key=""):
to_delete = Subscription.query(Subscription.model_key == modelKey, ancestor=ndb.Key(Account, userId)).fetch(keys_only=True)
if len(to_delete) > 0:
ndb.delete_multi(to_delete)
# Send updates to user's other devices
NotificationHelper.send_subscription_update(userId, device_key)
return 200
else:
# Subscription doesn't exist. Can't delete it
return 404
def get_users_subscribed_for_alliances(cls, event, notification):
keys = []
for team in event.alliance_teams:
keys.append(team)
keys.append("{}_{}".format(event.key_name, team)) # [email protected] key
keys.append("{}*".format(event.year)) # key for all events in year
keys.append(event.key_name)
users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch()
output = [user.user_id for user in users]
return output
def list_subscriptions(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return SubscriptionCollection(subscriptions = [])
userId = PushHelper.user_email_to_id(current_user.email())
subscriptions = Subscription.query( Subscription.user_id == userId ).fetch()
output = []
for subscription in subscriptions:
output.append(SubscriptionMessage(model_key = subscription.model_key, notifications = PushHelper.notification_string_from_enums(subscription.notification_types)))
return SubscriptionCollection(subscriptions = output)
def get_users_subscribed_to_match(cls, match, notification):
keys = []
for team in match.team_key_names:
keys.append(team)
keys.append("{}_{}".format(match.event.id(), team))
keys.append(match.key_name)
keys.append(match.event.id())
logging.info("Getting subscriptions for keys: "+str(keys))
users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch()
output = []
for user in users:
output.append(user.user_id)
return output
def list_subscriptions(self, request):
user_id = get_current_user_id(self.headers)
if user_id is None:
return SubscriptionCollection(subscriptions=[])
subscriptions = Subscription.query(ancestor=ndb.Key(Account, user_id)).fetch()
output = []
for subscription in subscriptions:
output.append(SubscriptionMessage(
model_key=subscription.model_key,
notifications=PushHelper.notification_string_from_enums(subscription.notification_types),
model_type=subscription.model_type))
return SubscriptionCollection(subscriptions=output)
def get_users_subscribed_to_match(cls, match, notification):
keys = []
for team in match.team_key_names:
keys.append(team)
keys.append("{}_{}".format(match.event_key_name, team))
keys.append("{}*".format(match.year)) # key for all events in year
keys.append(match.key_name)
keys.append(match.event_key_name)
users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch()
output = []
for user in users:
output.append(user.user_id)
return output
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_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 remove_subscription(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return BaseResponse(code=401, message="Unauthorized to remove subscription")
userId = PushHelper.user_email_to_id(current_user.email())
modelKey = request.model_key
to_delete = Subscription.query( Subscription.user_id == userId, Subscription.model_key == modelKey).fetch(keys_only=True)
if len(to_delete) > 0:
ndb.delete_multi(to_delete)
if request.device_key:
# Send updates to user's other devices
GCMMessageHelper.send_subscription_update(userId, request.device_key)
return BaseResponse(code=200, message="Subscriptions deleted")
else:
# Subscription doesn't exist. Can't delete it
return BaseResponse(code=404, message="Subscription not found")
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, event_key):
self._require_registration()
# Handle wildcard for all events in a year
event = None
is_wildcard = False
if event_key.endswith("*"):
try:
year = int(event_key[:-1])
except:
year = None
if year and year >= 1992 and year <= tba_config.MAX_YEAR:
event = Event(name="ALL {} EVENTS".format(year), year=year) # fake event for rendering
is_wildcard = True
else:
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
user = self.user_bundle.account.key
favorite = Favorite.query(
Favorite.model_key == event_key, Favorite.model_type == ModelType.EVENT, ancestor=user
).get()
subscription = Subscription.query(
Favorite.model_key == event_key, Favorite.model_type == ModelType.EVENT, ancestor=user
).get()
if not favorite and not subscription: # New entry; default to being a favorite
is_favorite = True
else:
is_favorite = favorite is not None
enabled_notifications = [
(en, NotificationType.render_names[en]) for en in NotificationType.enabled_event_notifications
]
self.template_values["event"] = event
self.template_values["is_wildcard"] = is_wildcard
self.template_values["is_favorite"] = is_favorite
self.template_values["subscription"] = subscription
self.template_values["enabled_notifications"] = enabled_notifications
self.response.out.write(jinja2_engine.render("mytba_event.html", self.template_values))
def add_subscription(cls, sub, device_key=""):
current = Subscription.query(Subscription.model_key == sub.model_key, ancestor=ndb.Key(Account, sub.user_id)).get()
if current is None:
# Subscription doesn't exist, add it
sub.put()
# Send updates to user's other devices
NotificationHelper.send_subscription_update(sub.user_id, device_key)
return 200
else:
if current.notification_types == sub.notification_types:
# Subscription already exists. Don't add it again
return 304
else:
# We're updating the settings
current.notification_types = sub.notification_types
current.put()
# Send updates to user's other devices
NotificationHelper.send_subscription_update(sub.user_id, device_key)
return 200
def get(self):
self._require_login('/account/register')
self._require_registration('/account/register')
user = self.user_bundle.account.key
favorites = Favorite.query(ancestor=user).fetch()
subscriptions = Subscription.query(ancestor=user).fetch()
favorites_by_type = defaultdict(list)
for fav in favorites:
favorites_by_type[ModelType.type_names[fav.model_type]].append(fav)
subscriptions_by_type = defaultdict(list)
for sub in subscriptions:
subscriptions_by_type[ModelType.type_names[sub.model_type]].append(sub)
now = datetime.datetime.now()
self.template_values['favorites_by_type'] = dict(favorites_by_type)
self.template_values['subscriptions_by_type'] = dict(subscriptions_by_type)
self.template_values['enabled_notifications'] = NotificationType.enabled_notifications
self.template_values['this_year'] = now.year
error = self.request.get('error')
if error:
if error == 'invalid_model':
error_message = "Invalid model key"
elif error == "no_sub_types":
error_message = "No notification types selected"
elif error == "invalid_account":
error_message = "Invalid account"
elif error == "invalid_year":
error_message = "You can only subscribe to the current year"
elif error == "sub_not_found":
error_message = "Subscription not found"
elif error == "fav_not_found":
error_message = "Favorite not found"
else:
error_message = "An unknown error occurred"
self.template_values['error_message'] = error_message
path = os.path.join(os.path.dirname(__file__), '../templates/mytba.html')
self.response.out.write(template.render(path, self.template_values))
def get(self):
year = date.today().year - 1
# Compile key regex
# Matches event (2014ctgro), [email protected] (frc2014_2014ctgro), firehose (2014*)
ps = "^{}[a-z]+|_{}[a-z]+|{}\*$".format(year, year, year)
logging.info("Pattern: {}".format(ps))
p = re.compile(ps)
subs = Subscription.query().fetch()
to_delete = []
for sub in subs:
if p.match(sub.model_key):
to_delete.append(sub.key)
count = len(to_delete)
if to_delete:
ndb.delete_multi(to_delete)
logging.info("Removed {} old subscriptions".format(count))
template_values = {'count': count}
path = os.path.join(os.path.dirname(__file__), '../../templates/admin/subs_clear_do.html')
self.response.out.write(template.render(path, template_values))
def insert(article, topic, source):
db_subscription = Subscription.update_or_create(Subscription.url == source.url,
url=source.url,
name=source.name,
image=source.image_url)
db_article = Article.update_or_create(Article.url == article.url,
source=db_subscription,
publish_date=article.publish_date,
url=article.url,
author="",
title=article.title,
description=article.description,
body=article.body,
preview_image=article.preview_image_url)
db_topic = Topic.update_or_create(Topic.source == db_subscription and
Topic.name == topic.name and
Topic.url == topic.url,
source=db_subscription,
name=topic.name,
url=topic.url)
try:
ArticleTopic.get(article=db_article, topic=db_topic)
except ArticleTopic.DoesNotExist:
ArticleTopic.create(article=db_article, topic=db_topic)
def get(self):
self._require_login('/account/register')
self._require_registration('/account/register')
user = self.user_bundle.account.key
favorites = Favorite.query(ancestor=user).fetch()
subscriptions = Subscription.query(ancestor=user).fetch()
team_keys = set()
team_fav = {}
team_subs = {}
event_keys = set()
event_fav = {}
event_subs = {}
events = []
for item in favorites + subscriptions:
if item.model_type == ModelType.TEAM:
team_keys.add(ndb.Key(Team, item.model_key))
if type(item) == Favorite:
team_fav[item.model_key] = item
elif type(item) == Subscription:
team_subs[item.model_key] = item
elif item.model_type == ModelType.EVENT:
if item.model_key.endswith('*'): # All year events wildcard
event_year = int(item.model_key[:-1])
events.append(Event( # add fake event for rendering
id=item.model_key,
short_name='ALL EVENTS',
event_short=item.model_key,
year=event_year,
start_date=datetime.datetime(event_year, 1, 1)
))
else:
event_keys.add(ndb.Key(Event, item.model_key))
if type(item) == Favorite:
event_fav[item.model_key] = item
elif type(item) == Subscription:
event_subs[item.model_key] = item
team_futures = ndb.get_multi_async(team_keys)
event_futures = ndb.get_multi_async(event_keys)
teams = sorted([team_future.get_result() for team_future in team_futures], key=lambda x: x.team_number)
team_fav_subs = []
for team in teams:
fav = team_fav.get(team.key.id(), None)
subs = team_subs.get(team.key.id(), None)
team_fav_subs.append((team, fav, subs))
events += [event_future.get_result() for event_future in event_futures]
events = sorted(events, key=lambda x: x.start_date)
event_fav_subs = []
for event in events:
fav = event_fav.get(event.key.id(), None)
subs = event_subs.get(event.key.id(), None)
event_fav_subs.append((event, fav, subs))
self.template_values['team_fav_subs'] = team_fav_subs
self.template_values['event_fav_subs'] = event_fav_subs
self.template_values['status'] = self.request.get('status')
self.template_values['year'] = datetime.datetime.now().year
self.response.out.write(jinja2_engine.render('mytba.html', self.template_values))
def subscriptions(self, limit=50, offset=0):
return (Subscription.select()
.join(UserSubscription)
.where(UserSubscription.user == self)
.limit(limit)
.offset(offset))
def get(self):
self._require_login()
self._require_registration()
user = self.user_bundle.account.key
favorites = Favorite.query(ancestor=user).fetch()
subscriptions = Subscription.query(ancestor=user).fetch()
team_keys = set()
team_fav = {}
team_subs = {}
event_keys = set()
event_fav = {}
event_subs = {}
events = []
match_keys = set()
match_event_keys = set()
match_fav = {}
match_subs = {}
for item in favorites + subscriptions:
if item.model_type == ModelType.TEAM:
team_keys.add(ndb.Key(Team, item.model_key))
if type(item) == Favorite:
team_fav[item.model_key] = item
elif type(item) == Subscription:
team_subs[item.model_key] = item
elif item.model_type == ModelType.MATCH:
match_keys.add(ndb.Key(Match, item.model_key))
match_event_keys.add(ndb.Key(Event, item.model_key.split('_')[0]))
if type(item) == Favorite:
match_fav[item.model_key] = item
elif type(item) == Subscription:
match_subs[item.model_key] = item
elif item.model_type == ModelType.EVENT:
if item.model_key.endswith('*'): # All year events wildcard
event_year = int(item.model_key[:-1])
events.append(Event( # add fake event for rendering
id=item.model_key,
short_name='ALL EVENTS',
event_short=item.model_key,
year=event_year,
start_date=datetime.datetime(event_year, 1, 1),
end_date=datetime.datetime(event_year, 1, 1)
))
else:
event_keys.add(ndb.Key(Event, item.model_key))
if type(item) == Favorite:
event_fav[item.model_key] = item
elif type(item) == Subscription:
event_subs[item.model_key] = item
team_futures = ndb.get_multi_async(team_keys)
event_futures = ndb.get_multi_async(event_keys)
match_futures = ndb.get_multi_async(match_keys)
match_event_futures = ndb.get_multi_async(match_event_keys)
teams = sorted([team_future.get_result() for team_future in team_futures], key=lambda x: x.team_number)
team_fav_subs = []
for team in teams:
fav = team_fav.get(team.key.id(), None)
subs = team_subs.get(team.key.id(), None)
team_fav_subs.append((team, fav, subs))
events += [event_future.get_result() for event_future in event_futures]
EventHelper.sort_events(events)
event_fav_subs = []
for event in events:
fav = event_fav.get(event.key.id(), None)
subs = event_subs.get(event.key.id(), None)
event_fav_subs.append((event, fav, subs))
matches = [match_future.get_result() for match_future in match_futures]
match_events = [match_event_future.get_result() for match_event_future in match_event_futures]
MatchHelper.natural_sort_matches(matches)
match_fav_subs_by_event = {}
for event in match_events:
match_fav_subs_by_event[event.key.id()] = (event, [])
for match in matches:
event_key = match.key.id().split('_')[0]
fav = match_fav.get(match.key.id(), None)
subs = match_subs.get(match.key.id(), None)
match_fav_subs_by_event[event_key][1].append((match, fav, subs))
event_match_fav_subs = sorted(match_fav_subs_by_event.values(), key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
event_match_fav_subs = sorted(event_match_fav_subs, key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
self.template_values['team_fav_subs'] = team_fav_subs
self.template_values['event_fav_subs'] = event_fav_subs
self.template_values['event_match_fav_subs'] = event_match_fav_subs
self.template_values['status'] = self.request.get('status')
self.template_values['year'] = datetime.datetime.now().year
self.response.out.write(jinja2_engine.render('mytba.html', self.template_values))
def get_users_subscribed(cls, model_key):
user_list = Subscription.query(Subscription.model_key == model_key).fetch()
output = []
for user in user_list:
output.append(user.user_id)
return output
