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 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)