def star(tid):
u = current_user()
Favorite.star(u.id, tid)
t = Topic.one(id=tid)
Topic.update(tid, heat=t.heat+3)
flash('收藏影评成功')
return redirect(url_for('.detail', tid=tid))
def test_all(self):
Favorite.objects.all().delete()
db_before = Favorite.all()
favorite = self.create_favorite()
favorite.save()
db_after = Favorite.all()
self.assertTrue(db_before != db_after)
def delete_favorite(self):
Favorite.objects.all().delete()
favorite = self.create_favorite()
favorite.save()
user = User.objects.get(username='******')
busline_id = favorite.busline.id
user_id = user.id
Favorite.delete_favorite(user_id, busline_id)
favorites = Favorite.objects.all()
self.assertEquals(0, len(favorites))
def test_add_favorite_304(self):
favorite = Favorite(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM)
favorite.put()
# Favorite already exists - return a 304
with patch.object(NotificationHelper, 'send_favorite_update') as mock_send_favorite_update:
self.assertEqual(MyTBAHelper.add_favorite(favorite), 304)
mock_send_favorite_update.assert_not_called()
def test_remove_favorite_200_sending_device_key(self):
favorite = Favorite(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM)
favorite_key = favorite.put()
# Favorite does not exist - 404
with patch.object(NotificationHelper, 'send_favorite_update') as mock_send_favorite_update, \
patch.object(ndb, 'delete_multi') as mock_delete:
self.assertEqual(MyTBAHelper.remove_favorite(favorite.user_id, favorite.model_key, favorite.model_type, 'sending_device_key'), 200)
mock_delete.assert_called_once_with([favorite_key])
mock_send_favorite_update.assert_called_once_with('user_id', 'sending_device_key')
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 test_favorites(self):
Favorite.objects.all().delete()
favorite = self.create_favorite()
favorite.save()
user = User.objects.get(username='******')
favorites = Favorite.favorites(user.id)
self.assertEquals(1, len(favorites))
def post(self, event_key):
self._require_login('/account/register')
self._require_registration('/account/register')
current_user_id = self.user_bundle.account.key.id()
if self.request.get('favorite'):
favorite = Favorite(parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.EVENT,
model_key=event_key)
MyTBAHelper.add_favorite(favorite)
else:
MyTBAHelper.remove_favorite(current_user_id, event_key)
subs = self.request.get_all('notification_types')
if subs:
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.EVENT,
model_key=event_key,
notification_types=[int(s) for s in subs])
MyTBAHelper.add_subscription(subscription)
else:
MyTBAHelper.remove_subscription(current_user_id, event_key)
self.redirect('/account/mytba?status=event_updated#my-events')
def get(self, match_key):
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 post(self, match_key):
self._require_registration()
current_user_id = self.user_bundle.account.key.id()
match = Match.get_by_id(match_key)
if self.request.get('favorite'):
favorite = Favorite(parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.MATCH,
model_key=match_key)
MyTBAHelper.add_favorite(favorite)
else:
MyTBAHelper.remove_favorite(current_user_id, match_key,
ModelType.MATCH)
subs = self.request.get_all('notification_types')
if subs:
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.MATCH,
model_key=match_key,
notification_types=[int(s) for s in subs])
MyTBAHelper.add_subscription(subscription)
else:
MyTBAHelper.remove_subscription(current_user_id, match_key,
ModelType.MATCH)
self.redirect('/account/mytba?status=match_updated#my-matches')
def index_all():
id = get_jwt_identity()
favorites = Favorite.select().join(
User,
on=Favorite.user_id).switch(Favorite).where(Favorite.user_id == id)
excluded_chefs = [c.chef_id for c in favorites]
recipes = Recipe.select().where((Recipe.user_id != id)
& Recipe.user_id.not_in(excluded_chefs))
return jsonify({
"status":
"success",
"recipe": [{
"id": recipe.id,
"id_owner": recipe.user.id,
"id_user": str(id),
"name": recipe.name,
"photo": recipe.photo,
"countrys": recipe.countrys,
"hour": recipe.hour,
"sec": recipe.sec,
"directions": recipe.directions,
"ingredients": recipe.ingredients,
"time": recipe.time,
"username": recipe.user.username,
"user_id": recipe.user.id,
"user_photo": recipe.user.photo
} for recipe in recipes]
}), 200
def get(self, team_number):
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 post(self, team_number):
self._require_registration()
current_user_id = self.user_bundle.account.key.id()
team_key = 'frc{}'.format(team_number)
if self.request.get('favorite'):
favorite = Favorite(parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.TEAM,
model_key=team_key)
MyTBAHelper.add_favorite(favorite)
else:
MyTBAHelper.remove_favorite(current_user_id, team_key,
ModelType.TEAM)
subs = self.request.get_all('notification_types')
if subs:
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.TEAM,
model_key=team_key,
notification_types=[int(s) for s in subs])
MyTBAHelper.add_subscription(subscription)
else:
MyTBAHelper.remove_subscription(current_user_id, team_key,
ModelType.TEAM)
self.redirect('/account/mytba?status=team_updated#my-teams')
def test_is_favorite(self):
Favorite.objects.all().delete()
favorite = self.create_favorite()
favorite.save()
user = User.objects.get(username='******')
busline_id = favorite.busline.id
user_id = user.id
return_value = Favorite.is_favorite(user_id, busline_id)
self.assertTrue(return_value)
def get(self, model_type):
if not self.user_bundle.user:
self.response.set_status(401)
return
favorites = Favorite.query(
Favorite.model_type==int(model_type),
ancestor=ndb.Key(Account, self.user_bundle.user.user_id())).fetch()
self.response.out.write(json.dumps([ModelToDict.favoriteConverter(fav) for fav in favorites]))
def list_favorites(self, request):
user_id = get_current_user_id(self.headers)
if user_id is None:
return FavoriteCollection(favorites=[])
favorites = Favorite.query(ancestor=ndb.Key(Account, user_id)).fetch()
output = []
for favorite in favorites:
output.append(FavoriteMessage(model_key=favorite.model_key, model_type=favorite.model_type))
return FavoriteCollection(favorites=output)
def add_favorite(cls, fav, device_key=""):
if Favorite.query(Favorite.model_key == fav.model_key, ancestor=ndb.Key(Account, fav.user_id)).count() == 0:
# Favorite doesn't exist, add it
fav.put()
# Send updates to user's other devices
NotificationHelper.send_favorite_update(fav.user_id, device_key)
return 200
else:
# Favorite already exists. Don't add it again
return 304
def remove_favorite(cls, userId, modelKey, device_key=""):
to_delete = Favorite.query(Favorite.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_favorite_update(userId, device_key)
return 200
else:
# Favorite doesn't exist. Can't delete it
return 404
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 remove_favorite(cls, userId, modelKey, device_key=""):
to_delete = Favorite.query(Favorite.model_key == modelKey, ancestor=ndb.Key(Account, userId)).fetch(keys_only=True)
if len(to_delete) > 0:
ndb.delete_multi(to_delete)
if device_key:
# Send updates to user's other devices
NotificationHelper.send_favorite_update(userId, device_key)
return 200
else:
# Favorite doesn't exist. Can't delete it
return 404
def add_favorite(cls, fav, device_key=""):
if Favorite.query(Favorite.model_key == fav.model_key, ancestor=ndb.Key(Account, fav.user_id)).count() == 0:
# Favorite doesn't exist, add it
fav.put()
if device_key:
# Send updates to user's other devices
NotificationHelper.send_favorite_update(fav.user_id, device_key)
return 200
else:
# Favorite already exists. Don't add it again
return 304
def list_favorites(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return FavoriteCollection(favorites=[])
user_id = PushHelper.user_email_to_id(current_user.email())
favorites = Favorite.query(ancestor=ndb.Key(Account, user_id)).fetch()
output = []
for favorite in favorites:
output.append(FavoriteMessage(model_key=favorite.model_key, model_type=favorite.model_type))
return FavoriteCollection(favorites=output)
def list_favorites(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return FavoriteCollection(favorites=[])
user_id = PushHelper.user_email_to_id(current_user.email())
favorites = Favorite.query(ancestor=ndb.Key(Account, user_id)).fetch()
output = []
for favorite in favorites:
output.append(FavoriteMessage(model_key=favorite.model_key, model_type=favorite.model_type))
return FavoriteCollection(favorites=output)
def detail(tid):
m = Topic.get(tid)
# 是否封锁
m = is_active(m, 502)
u = current_user()
token = new_csrf_token()
t = Topic.one(id=tid)
Topic.update(tid, heat=t.heat + 1)
starred = Favorite.starred(u.id, tid)
liked = Like.liked(u.id, tid)
# 传递 topic 的所有 reply 到 页面中
return render_template("topic/detail.html", topic=m, user=u, token=token, starred=starred, liked=liked)
def test_add_favorite_200_sending_device_key(self):
favorite = Favorite(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM)
# Favorite does not already exist - return a 200 and put
with patch.object(NotificationHelper, 'send_favorite_update') as mock_send_favorite_update, \
patch.object(favorite, 'put') as mock_put:
self.assertEqual(MyTBAHelper.add_favorite(favorite, 'sending_device_key'), 200)
mock_put.assert_called_once()
mock_send_favorite_update.assert_called_once_with('user_id', 'sending_device_key')
def list_favorites(self, request):
user_id = get_current_user_id(self.headers)
if user_id is None:
return FavoriteCollection(favorites=[])
favorites = Favorite.query(ancestor=ndb.Key(Account, user_id)).fetch()
output = []
for favorite in favorites:
output.append(
FavoriteMessage(model_key=favorite.model_key,
model_type=favorite.model_type))
return FavoriteCollection(favorites=output)
def post(self):
current_user = get_jwt_identity()
data = faves_parser.parse_args()
u = User.query.filter_by(email=data['user_email']).first()
if not u:
return {'error': 'user not found'}, 404
if current_user != u.email:
return {'error': 'user cannot fave for other users'}, 403
f = Favorite(u.id, data['url'])
db.session.add(f)
db.session.commit()
return 201
def get(self, event_key):
self._require_login('/account/register')
self._require_registration('/account/register')
# 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( # fake event for rendering
name="ALL {} EVENTS".format(year),
year=year,
)
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 get(self):
self._require_login()
self._require_registration()
user = self.user_bundle.account.key
now = datetime.datetime.now()
team_favorites_future = Favorite.query(Favorite.model_type == ModelType.TEAM, ancestor=user).fetch_async()
live_events = EventHelper.getEventsWithinADay()
favorite_team_keys = map(lambda f: ndb.Key(Team, f.model_key), team_favorites_future.get_result())
favorite_teams_future = ndb.get_multi_async(favorite_team_keys)
live_eventteams_futures = []
for event in live_events:
live_eventteams_futures.append(EventTeamsQuery(event.key_name).fetch_async())
favorite_teams = [team_future.get_result() for team_future in favorite_teams_future]
favorite_teams_events_futures = []
for team in favorite_teams:
favorite_teams_events_futures.append(TeamYearEventsQuery(team.key_name, now.year).fetch_async())
live_events_with_teams = EventTeamStatusHelper.buildEventTeamStatus(live_events, live_eventteams_futures, favorite_teams)
future_events_by_event = {}
for team, events_future in zip(favorite_teams, favorite_teams_events_futures):
events = events_future.get_result()
if not events:
continue
EventHelper.sort_events(events)
next_event = next((e for e in events if e.start_date > now and not e.within_a_day), None)
if next_event:
if next_event.key_name not in future_events_by_event:
future_events_by_event[next_event.key_name] = (next_event, [])
future_events_by_event[next_event.key_name][1].append(team)
future_events_with_teams = []
for event_key, data in future_events_by_event.iteritems():
future_events_with_teams.append((data[0], TeamHelper.sortTeams(data[1])))
future_events_with_teams.sort(key=lambda x: x[0].name)
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
self.template_values.update({
'live_events_with_teams': live_events_with_teams,
'future_events_with_teams': future_events_with_teams,
})
path = os.path.join(os.path.dirname(__file__), '../templates/mytba_live.html')
self.response.out.write(template.render(path, self.template_values))
def index_number(user_id_param):
favorites = Favorite.select().join(
User, on=Favorite.user_id).switch(Favorite).where(
Favorite.user_id == user_id_param)
following = len([c.chef_id for c in favorites])
favorites = Favorite.select().join(
User, on=Favorite.user_id).switch(Favorite).where(
Favorite.chef_id == user_id_param)
followers = len([c.user_id for c in favorites])
my_recipes = Recipe.select().where(Recipe.user_id == user_id_param)
recipes = len([c.id for c in my_recipes])
return jsonify({
"status": "success",
"number": {
"following": following,
"followers": followers,
"recipes": recipes,
}
}), 200
def post(self):
if not self.user_bundle.user:
self.response.set_status(401)
return
model_type = int(self.request.get("model_type"))
model_key = self.request.get("model_key")
user_id = self.user_bundle.user.user_id()
fav = Favorite(parent=ndb.Key(Account, user_id),
user_id=user_id,
model_key=model_key,
model_type=model_type)
MyTBAHelper.add_favorite(fav)
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
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 mark_view():
user = User.load(user_name=session.get('username'))
tweet = Tweet.load(int(request.form.get('tweet_id')))
state = ''
if tweet.is_faved(user):
state = 'removed'
# user.remove_favorite(tweet)
else:
view = Favorite(user_id=user.id, tweet_id=tweet.id)
# user.update_profile(np.array(tweet.vector))
DB.get_instance().add(view)
state = 'added'
DB.get_instance().commit()
return state
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 remove_favorite(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return BaseResponse(code=401, message="Unauthorized to remove favorite")
userId = PushHelper.user_email_to_id(current_user.email())
modelKey = request.model_key
to_delete = Favorite.query( Favorite.user_id == userId, Favorite.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_favorite_update(userId, request.device_key)
return BaseResponse(code=200, message="Favorites deleted")
else:
# Favorite doesn't exist. Can't delete it
return BaseResponse(code=404, message="Favorite 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 add_favorite(self, request):
current_user = endpoints.get_current_user()
if current_user is None:
return BaseResponse(code=401, message="Unauthorized to add favorite")
userId = PushHelper.user_email_to_id(current_user.email())
modelKey = request.model_key
if Favorite.query( Favorite.user_id == userId, Favorite.model_key == modelKey).count() == 0:
# Favorite doesn't exist, add it
Favorite( user_id = userId, model_key = modelKey).put()
if request.device_key:
# Send updates to user's other devices
logging.info("Sending favorite update to user other devices")
GCMMessageHelper.send_favorite_update(userId, request.device_key)
return BaseResponse(code=200, message="Favorite added")
else:
# Favorite already exists. Don't add it again
return BaseResponse(code=304, message="Favorite already exists")
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 display_substitute(self, rep):
"""Method that displays the chosen substitute"""
self.connect()
try:
self.cursor.execute(sql.USE_DATABASE)
self.cursor.execute(sql.SELECT_SUBSTITUTE, (rep, ))
chosen_substitute = self.cursor.fetchone()
# Finds substitute's store(s)
self.cursor.execute(sql.SELECT_STORE, (rep, ))
store_substitute = \
[''.join(store) for store in self.cursor.fetchall()]
# fetchall returns a list of stores_substitute
print(Fore.MAGENTA + "_______________________________"
"_______________________________\n"
"Voici les détails du substitut choisi :")
print(Fore.RESET)
print(f"IDENTIFIANT........: {chosen_substitute[0]}\n"
f"NOM................: {chosen_substitute[1]}\n"
f"MARQUE.............: {chosen_substitute[4]}\n"
f"CODE BARRE.........: {chosen_substitute[3]}\n"
f"NUTRISCORE.........: {chosen_substitute[2]}\n"
f"URL Openfoodfacts..: {chosen_substitute[5]}\n"
f"LIEU(X) DE VENTE...: {store_substitute}\n"
f"_______________________________"
"_______________________________\n")
# Creates a favorite object
self.favorite = Favorite(chosen_substitute[1],
chosen_substitute[2],
chosen_substitute[3],
chosen_substitute[4],
chosen_substitute[5],
str(store_substitute))
self.disconnect()
except mc.Error as err:
print(f"Erreur lors de l'affichage des détails du substitut. "
f"Détails de l'erreur : {err}")
self.listen_choice_four(self.favorite)
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):
self._require_registration()
user = self.user_bundle.account.key
now = datetime.datetime.now()
team_favorites_future = Favorite.query(Favorite.model_type == ModelType.TEAM, ancestor=user).fetch_async()
favorite_team_keys = map(lambda f: ndb.Key(Team, f.model_key), team_favorites_future.get_result())
favorite_teams_future = ndb.get_multi_async(favorite_team_keys)
favorite_teams = [team_future.get_result() for team_future in favorite_teams_future]
favorite_teams_events_futures = []
for team in favorite_teams:
favorite_teams_events_futures.append(TeamYearEventsQuery(team.key_name, now.year).fetch_async())
past_events_by_event = {}
live_events_by_event = {}
future_events_by_event = {}
for team, events_future in zip(favorite_teams, favorite_teams_events_futures):
events = events_future.get_result()
if not events:
continue
EventHelper.sort_events(events) # Sort by date
for event in events:
if event.within_a_day:
if event.key_name not in live_events_by_event:
live_events_by_event[event.key_name] = (event, [])
live_events_by_event[event.key_name][1].append(team)
elif event.start_date < now:
if event.key_name not in past_events_by_event:
past_events_by_event[event.key_name] = (event, [])
past_events_by_event[event.key_name][1].append(team)
else:
if event.key_name not in future_events_by_event:
future_events_by_event[event.key_name] = (event, [])
future_events_by_event[event.key_name][1].append(team)
past_events = []
past_eventteams = []
for past_event, past_eventteam in past_events_by_event.itervalues():
past_events.append(past_event)
past_eventteams.append(past_eventteam)
past_events_with_teams = EventTeamStatusHelper.buildEventTeamStatus(past_events, past_eventteams, favorite_teams)
past_events_with_teams.sort(key=lambda x: x[0].name)
past_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
past_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
live_events = []
live_eventteams = []
for live_event, live_eventteam in live_events_by_event.itervalues():
live_events.append(live_event)
live_eventteams.append(live_eventteam)
live_events_with_teams = EventTeamStatusHelper.buildEventTeamStatus(live_events, live_eventteams, favorite_teams)
live_events_with_teams.sort(key=lambda x: x[0].name)
future_events_with_teams = []
for event_key, data in future_events_by_event.iteritems():
future_events_with_teams.append((data[0], TeamHelper.sortTeams(data[1])))
future_events_with_teams.sort(key=lambda x: x[0].name)
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
# Resolve future before rendering
for _, teams_and_statuses_future in past_events_with_teams:
for team_and_status_future in teams_and_statuses_future:
team_and_status_future[1] = team_and_status_future[1].get_result()
for _, teams_and_statuses_future in live_events_with_teams:
for team_and_status_future in teams_and_statuses_future:
team_and_status_future[1] = team_and_status_future[1].get_result()
self.template_values.update({
'past_events_with_teams': past_events_with_teams,
'live_events_with_teams': live_events_with_teams,
'future_events_with_teams': future_events_with_teams,
})
path = os.path.join(os.path.dirname(__file__), '../templates/mytba_live.html')
self.response.out.write(template.render(path, self.template_values))
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 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(self):
self._require_registration()
user = self.user_bundle.account.key
now = datetime.datetime.now()
year = self.request.get('year')
if year and year.isdigit():
year = int(year)
else:
year = now.year
team_favorites_future = Favorite.query(Favorite.model_type == ModelType.TEAM, ancestor=user).fetch_async()
favorite_team_keys = map(lambda f: ndb.Key(Team, f.model_key), team_favorites_future.get_result())
favorite_teams_future = ndb.get_multi_async(favorite_team_keys)
favorite_teams = [team_future.get_result() for team_future in favorite_teams_future]
favorite_teams_events_futures = []
favorite_teams_awards_futures = {}
for team in favorite_teams:
favorite_teams_events_futures.append(TeamYearEventsQuery(team.key_name, year).fetch_async())
favorite_teams_awards_futures[team.key.id()] = TeamYearAwardsQuery(team.key_name, year).fetch_async()
past_events_by_event = {}
live_events_by_event = {}
future_events_by_event = {}
favorite_event_team_keys = []
for team, events_future in zip(favorite_teams, favorite_teams_events_futures):
events = events_future.get_result()
if not events:
continue
EventHelper.sort_events(events) # Sort by date
for event in events:
favorite_event_team_keys.append(ndb.Key(EventTeam, '{}_{}'.format(event.key.id(), team.key.id())))
if event.within_a_day:
if event.key_name not in live_events_by_event:
live_events_by_event[event.key_name] = (event, [])
live_events_by_event[event.key_name][1].append(team)
elif event.start_date < now:
if event.key_name not in past_events_by_event:
past_events_by_event[event.key_name] = (event, [])
past_events_by_event[event.key_name][1].append(team)
else:
if event.key_name not in future_events_by_event:
future_events_by_event[event.key_name] = (event, [])
future_events_by_event[event.key_name][1].append(team)
event_team_awards = defaultdict(lambda: defaultdict(list))
for team_key, awards_future in favorite_teams_awards_futures.items():
for award in awards_future.get_result():
event_team_awards[award.event.id()][team_key].append(award)
ndb.get_multi(favorite_event_team_keys) # Warms context cache
past_events_with_teams = []
for event, teams in past_events_by_event.itervalues():
teams_and_statuses = []
for team in teams:
event_team = EventTeam.get_by_id('{}_{}'.format(event.key.id(), team.key.id())) # Should be in context cache
status_str = {
'alliance': EventTeamStatusHelper.generate_team_at_event_alliance_status_string(team.key.id(), event_team.status),
'playoff': EventTeamStatusHelper.generate_team_at_event_playoff_status_string(team.key.id(), event_team.status),
}
teams_and_statuses.append((
team,
event_team.status,
status_str,
AwardHelper.organizeAwards(event_team_awards[event.key.id()][team.key.id()])
))
teams_and_statuses.sort(key=lambda x: x[0].team_number)
past_events_with_teams.append((event, teams_and_statuses))
past_events_with_teams.sort(key=lambda x: x[0].name)
past_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
past_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
live_events_with_teams = []
for event, teams in live_events_by_event.itervalues():
teams_and_statuses = []
for team in teams:
event_team = EventTeam.get_by_id('{}_{}'.format(event.key.id(), team.key.id())) # Should be in context cache
status_str = {
'alliance': EventTeamStatusHelper.generate_team_at_event_alliance_status_string(team.key.id(), event_team.status),
'playoff': EventTeamStatusHelper.generate_team_at_event_playoff_status_string(team.key.id(), event_team.status),
}
teams_and_statuses.append((
team,
event_team.status,
status_str
))
teams_and_statuses.sort(key=lambda x: x[0].team_number)
live_events_with_teams.append((event, teams_and_statuses))
live_events_with_teams.sort(key=lambda x: x[0].name)
live_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
live_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
future_events_with_teams = []
for event, teams in future_events_by_event.itervalues():
teams.sort(key=lambda t: t.team_number)
future_events_with_teams.append((event, teams))
future_events_with_teams.sort(key=lambda x: x[0].name)
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
self.template_values.update({
'year': year,
'past_only': year < now.year,
'past_events_with_teams': past_events_with_teams,
'live_events_with_teams': live_events_with_teams,
'future_events_with_teams': future_events_with_teams,
})
path = os.path.join(os.path.dirname(__file__), '../templates/mytba_live.html')
self.response.out.write(template.render(path, self.template_values))
def user_profile(user, params, lang):
origin_user = user
uuid = params.get("uuid", "")
if uuid:
user = User.select().where(User.uuid == uuid).first()
if not user:
return {"error_code": 20002, "msg": "user not exist"}
profile = user.profile.first()
languages = []
ul = UserLanguage.select().where(UserLanguage.user == user)
for u in ul:
languages.append(dict(
language_id=u.id,
name=u.name,
level=u.level,
))
out = dict()
# user self can get private information
if not uuid:
out["reg_step"] = user.reg_step
out["id_number"] = "%s********%s" % (profile.id_number[:6], profile.id_number[14:]) if profile.id_number else ""
out["alipay"] = profile.alipay
out["email"] = user.email
out["phone"] = user.phone
out["name"] = profile.name
out["username"] = user.username
out["avatar"] = widget.avatar(profile.avatar)
out["completeness"] = profile.completeness
out["visibility"] = profile.visibility
out["level"] = profile.level
out["title"] = profile.title
out["overview"] = profile.overview
out["hourly"] = profile.hourly
out["english"] = profile.english
out["skills"] = utils.loads(profile.skills) if profile.skills else []
out["available"] = profile.available
out["workload"] = profile.workload
location = {}
if profile.location_id:
city = widget.get_location(profile.location_id)
province = widget.get_location(city.parent_id)
location["location_id"] = profile.location_id
location["name"] = utils.lang_map_name(city.name, city.ename, lang)
location["parent_id"] = province.id
location["parent_name"] = utils.lang_map_name(province.name, province.ename, lang)
out["location"] = location
out["address"] = profile.address
out["postcode"] = profile.postcode
out['id'] = user.uuid
out["languages"] = languages
out["imid"] = user.id
if uuid:
favorites = Favorite.select().where(Favorite.user==origin_user, Favorite.target_id==profile.user_id, Favorite.ftype == 'REQ').first()
if favorites:
out["favorite"] = True
else:
out["favorite"] = False
# 开发者的评价数量和平均得分
score = UserStatistics.select(UserStatistics.eveluate_num, UserStatistics.aver_score).where(UserStatistics.user == user).first()
out["eveluate_num"] = score.eveluate_num if score else 0
out["aver_score"] = score.aver_score if score else 0
return {"error_code": 0, "msg": "ok", "profile": out}
def _render(self, *args, **kw):
week_events = EventHelper.getWeekEvents()
special_webcasts = FirebasePusher.get_special_webcasts()
events = {}
for event in week_events:
events[event.key.id()] = event
# Calculate popular teams
# Get cached team keys
event_team_keys = memcache.get_multi(events.keys(), namespace='event-team-keys')
# Get uncached team keys
to_query = set(events.keys()).difference(event_team_keys.keys())
event_teams_futures = [(
event_key,
EventTeam.query(EventTeam.event == ndb.Key(Event, event_key)).fetch_async(projection=[EventTeam.team])
) for event_key in to_query]
# Merge cached and uncached team keys
for event_key, event_teams in event_teams_futures:
event_team_keys[event_key] = [et.team.id() for et in event_teams.get_result()]
memcache.set_multi(event_team_keys, 60*60*24, namespace='event-team-keys')
team_keys = []
team_events = {}
for event_key, event_team_keys in event_team_keys.items():
team_keys += event_team_keys
for team_key in event_team_keys:
team_events[team_key] = events[event_key]
# Get cached counts
team_favorite_counts = memcache.get_multi(team_keys, namespace='team-favorite-counts')
# Get uncached counts
to_count = set(team_keys).difference(team_favorite_counts.keys())
count_futures = [(
team_key,
Favorite.query(Favorite.model_key == team_key).count_async()
) for team_key in to_count]
# Merge cached and uncached counts
for team_key, count_future in count_futures:
team_favorite_counts[team_key] = count_future.get_result()
memcache.set_multi(team_favorite_counts, 60*60*24, namespace='team-favorite-counts')
# Sort to get top popular teams
popular_team_keys = []
for team_key, _ in sorted(team_favorite_counts.items(), key=lambda tc: -tc[1])[:25]:
popular_team_keys.append(ndb.Key(Team, team_key))
popular_teams = sorted(ndb.get_multi(popular_team_keys), key=lambda team: team.team_number)
popular_teams_events = []
for team in popular_teams:
popular_teams_events.append((team, team_events[team.key.id()]))
self.template_values.update({
"events": week_events,
"any_webcast_online": any(w.get('status') == 'online' for w in special_webcasts),
"special_webcasts": special_webcasts,
"popular_teams_events": popular_teams_events,
})
path = os.path.join(os.path.dirname(__file__), '../templates/index_competitionseason.html')
return template.render(path, self.template_values)
