def render_recommended_feed(context, recommended_feeds, unmoderated=False): user = get_user(context['user']) usersub = None if context['user'].is_authenticated: usersub = UserSubscription.objects.filter( user=user, feed=recommended_feeds[0].feed) recommended_feed = recommended_feeds and recommended_feeds[0] feed_icon = MFeedIcon.objects(feed_id=recommended_feed.feed_id) if recommended_feed: return { 'recommended_feed': recommended_feed, 'description': recommended_feed.description or recommended_feed.feed.data.feed_tagline, 'usersub': usersub, 'feed_icon': feed_icon and feed_icon[0], 'user': context['user'], 'has_next_page': len(recommended_feeds) > 1, 'unmoderated': unmoderated, 'today': datetime.datetime.now(), }
def add_site_authed(request): code = 0 url = request.GET['url'] folder = request.GET['folder'] new_folder = request.GET.get('new_folder') callback = request.GET['callback'] user = get_user(request) if not url: code = -1 else: if new_folder: usf, _ = UserSubscriptionFolders.objects.get_or_create(user=user) usf.add_folder(folder, new_folder) folder = new_folder code, message, us = UserSubscription.add_subscription( user=user, feed_address=url, folder=folder, bookmarklet=True ) if code > 0: message = 'OK' logging.user(user, "~FRAdding authed URL from site: ~SB%s (in %s)" % (url, folder), request=request) return HttpResponse(callback + '(' + json.encode({ 'code': code, 'message': message, 'usersub': us and us.feed_id, }) + ')', mimetype='text/plain')
def feeds_trainer(request): classifiers = [] feed_id = request.REQUEST.get('feed_id') user = get_user(request) usersubs = UserSubscription.objects.filter(user=user, active=True) if feed_id: feed = get_object_or_404(Feed, pk=feed_id) usersubs = usersubs.filter(feed=feed) usersubs = usersubs.select_related('feed').order_by( '-feed__stories_last_month') for us in usersubs: if (not us.is_trained and us.feed.stories_last_month > 0) or feed_id: classifier = dict() classifier['classifiers'] = get_classifiers_for_user( user, us.feed.pk) classifier['feed_id'] = us.feed.pk classifier['stories_last_month'] = us.feed.stories_last_month classifier['feed_tags'] = json.decode( us.feed.data.popular_tags ) if us.feed.data.popular_tags else [] classifier['feed_authors'] = json.decode( us.feed.data.popular_authors ) if us.feed.data.popular_authors else [] classifiers.append(classifier) logging.user(user, "~FGLoading Trainer: ~SB%s feeds" % (len(classifiers))) return classifiers
def load_feed_statistics(request, feed_id): user = get_user(request) stats = dict() feed = get_object_or_404(Feed, pk=feed_id) feed.count_subscribers() feed.set_next_scheduled_update(verbose=True, skip_scheduling=True) feed.save_feed_story_history_statistics() feed.save_classifier_counts() # Dates of last and next update stats['active'] = feed.active stats['last_update'] = relative_timesince(feed.last_update) if feed.is_push: stats['next_update'] = "real-time..." else: stats['next_update'] = relative_timeuntil(feed.next_scheduled_update) # Minutes between updates update_interval_minutes, _ = feed.get_next_scheduled_update(force=True, verbose=False) if feed.is_push: stats['update_interval_minutes'] = 0 else: stats['update_interval_minutes'] = update_interval_minutes original_active_premium_subscribers = feed.active_premium_subscribers original_premium_subscribers = feed.premium_subscribers feed.active_premium_subscribers = max(feed.active_premium_subscribers+1, 1) feed.premium_subscribers += 1 premium_update_interval_minutes, _ = feed.get_next_scheduled_update(force=True, verbose=False) feed.active_premium_subscribers = original_active_premium_subscribers feed.premium_subscribers = original_premium_subscribers if feed.is_push: stats['premium_update_interval_minutes'] = 0 else: stats['premium_update_interval_minutes'] = premium_update_interval_minutes # Stories per month - average and month-by-month breakout average_stories_per_month, story_count_history = feed.average_stories_per_month, feed.data.story_count_history stats['average_stories_per_month'] = average_stories_per_month stats['story_count_history'] = story_count_history and json.decode(story_count_history) # Subscribers stats['subscriber_count'] = feed.num_subscribers stats['stories_last_month'] = feed.stories_last_month stats['last_load_time'] = feed.last_load_time stats['premium_subscribers'] = feed.premium_subscribers stats['active_subscribers'] = feed.active_subscribers stats['active_premium_subscribers'] = feed.active_premium_subscribers # Classifier counts stats['classifier_counts'] = json.decode(feed.data.feed_classifier_counts) # Fetch histories timezone = user.profile.timezone stats['feed_fetch_history'] = MFeedFetchHistory.feed_history(feed_id, timezone=timezone) stats['page_fetch_history'] = MPageFetchHistory.feed_history(feed_id, timezone=timezone) stats['feed_push_history'] = MFeedPushHistory.feed_history(feed_id, timezone=timezone) logging.user(request, "~FBStatistics: ~SB%s ~FG(%s/%s/%s subs)" % (feed, feed.num_subscribers, feed.active_subscribers, feed.premium_subscribers,)) return stats
def add_site_authed(request): code = 0 url = request.GET['url'] folder = request.GET['folder'] new_folder = request.GET.get('new_folder') callback = request.GET['callback'] user = get_user(request) if not url: code = -1 else: if new_folder: usf, _ = UserSubscriptionFolders.objects.get_or_create(user=user) usf.add_folder(folder, new_folder) folder = new_folder code, message, us = UserSubscription.add_subscription( user=user, feed_address=url, folder=folder, bookmarklet=True ) if code > 0: message = 'OK' logging.user(user, "~FRAdding authed URL from site: ~SB%s (in %s)" % (url, folder), request=request) return HttpResponse(callback + '(' + json.encode({ 'code': code, 'message': message, 'usersub': us and us.feed_id, }) + ')', content_type='text/plain')
def set_notifications_for_feed(request): user = get_user(request) feed_id = request.POST['feed_id'] notification_types = request.POST.getlist('notification_types') notification_filter = request.POST.get('notification_filter') try: notification = MUserFeedNotification.objects.get(user_id=user.pk, feed_id=feed_id) except MUserFeedNotification.DoesNotExist: params = { "user_id": user.pk, "feed_id": feed_id, } notification = MUserFeedNotification.objects.create(**params) web_was_off = not notification.is_web notification.is_focus = bool(notification_filter == "focus") notification.is_email = bool('email' in notification_types) notification.is_ios = bool('ios' in notification_types) notification.is_android = bool('android' in notification_types) notification.is_web = bool('web' in notification_types) notification.save() if (not notification.is_email and not notification.is_ios and not notification.is_android and not notification.is_web): notification.delete() r = redis.Redis(connection_pool=settings.REDIS_PUBSUB_POOL) if web_was_off and notification.is_web: r.publish(user.username, 'notification:setup:%s' % feed_id) notifications_by_feed = MUserFeedNotification.feeds_for_user(user.pk) return {"notifications_by_feed": notifications_by_feed}
def load_activities(request): user_id = request.REQUEST.get("user_id", None) if user_id: user_id = int(user_id) user = User.objects.get(pk=user_id) else: user = get_user(request) user_id = user.pk public = user_id != request.user.pk page = max(1, int(request.REQUEST.get("page", 1))) limit = request.REQUEST.get("limit", 4) activities, has_next_page = MActivity.user(user_id, page=page, limit=limit, public=public) format = request.REQUEST.get("format", None) data = { "activities": activities, "page": page, "has_next_page": has_next_page, "username": (user.username if public else "You"), } if format == "html": return render_to_response("reader/activities_module.xhtml", data, context_instance=RequestContext(request)) else: return json.json_response(request, data)
def load_starred_stories(request): user = get_user(request) offset = int(request.REQUEST.get('offset', 0)) limit = int(request.REQUEST.get('limit', 10)) page = int(request.REQUEST.get('page', 0)) if page: offset = limit * page mstories = MStarredStory.objects(user_id=user.pk).order_by('-starred_date')[offset:offset+limit] stories = Feed.format_stories(mstories) for story in stories: story_date = localtime_for_timezone(story['story_date'], user.profile.timezone) now = localtime_for_timezone(datetime.datetime.now(), user.profile.timezone) story['short_parsed_date'] = format_story_link_date__short(story_date, now) story['long_parsed_date'] = format_story_link_date__long(story_date, now) starred_date = localtime_for_timezone(story['starred_date'], user.profile.timezone) story['starred_date'] = format_story_link_date__long(starred_date, now) story['read_status'] = 1 story['starred'] = True story['intelligence'] = { 'feed': 0, 'author': 0, 'tags': 0, 'title': 0, } logging.user(request.user, "~FCLoading starred stories: ~SB%s stories" % (len(stories))) return dict(stories=stories)
def refresh_feeds(request): user = get_user(request) feeds = {} user_subs = UserSubscription.objects.select_related('feed').filter(user=user, active=True) UNREAD_CUTOFF = datetime.datetime.utcnow() - datetime.timedelta(days=settings.DAYS_OF_UNREAD) favicons_fetching = [int(f) for f in request.POST.getlist('favicons_fetching')] for sub in user_subs: if (sub.needs_unread_recalc or sub.unread_count_updated < UNREAD_CUTOFF or sub.oldest_unread_story_date < UNREAD_CUTOFF): sub.calculate_feed_scores(silent=True) feeds[sub.feed.pk] = { 'ps': sub.unread_count_positive, 'nt': sub.unread_count_neutral, 'ng': sub.unread_count_negative, } if sub.feed.has_feed_exception or sub.feed.has_page_exception: feeds[sub.feed.pk]['has_exception'] = True feeds[sub.feed.pk]['exception_type'] = 'feed' if sub.feed.has_feed_exception else 'page' feeds[sub.feed.pk]['feed_address'] = sub.feed.feed_address feeds[sub.feed.pk]['exception_code'] = sub.feed.exception_code if request.POST.get('check_fetch_status', False): feeds[sub.feed.pk]['not_yet_fetched'] = not sub.feed.fetched_once if sub.feed.pk in favicons_fetching: feeds[sub.feed.pk]['favicon'] = sub.feed.icon.data feeds[sub.feed.pk]['favicon_color'] = sub.feed.icon.color feeds[sub.feed.pk]['favicon_fetching'] = bool(not (sub.feed.icon.not_found or sub.feed.icon.data)) return {'feeds': feeds}
def story_public_comments(request): format = request.REQUEST.get('format', 'json') relative_user_id = request.REQUEST.get('user_id', None) feed_id = int(request.REQUEST['feed_id']) story_id = request.REQUEST['story_id'] if not relative_user_id: relative_user_id = get_user(request).pk stories = MSharedStory.objects.filter(story_feed_id=feed_id, story_guid=story_id).limit(1) stories = Feed.format_stories(stories) stories, profiles = MSharedStory.stories_with_comments_and_profiles(stories, relative_user_id, check_all=True, public=True) if format == 'html': stories = MSharedStory.attach_users_to_stories(stories, profiles) return render_to_response('social/story_comments.xhtml', { 'story': stories[0], }, context_instance=RequestContext(request)) else: return json.json_response(request, { 'comments': stories[0]['public_comments'], 'user_profiles': profiles, })
def render_feeds_skeleton(context): user = get_user(context['user']) return { 'user': user, 'MEDIA_URL': settings.MEDIA_URL, }
def render_manage_module(context): user = get_user(context['user']) return { 'user': user, 'user_profile': user.profile, }
def profile(request): user = get_user(request.user) user_id = request.GET.get('user_id', user.pk) include_activities_html = request.REQUEST.get('include_activities_html', None) user_profile = MSocialProfile.get_user(user_id) user_profile.count_follows() user_profile = user_profile.to_json(include_follows=True, common_follows_with_user=user.pk) profile_ids = set(user_profile['followers_youknow'] + user_profile['followers_everybody'] + user_profile['following_youknow'] + user_profile['following_everybody']) profiles = MSocialProfile.profiles(profile_ids) activities, _ = MActivity.user(user_id, page=1, public=True) logging.user(request, "~BB~FRLoading social profile: %s" % user_profile['username']) payload = { 'user_profile': user_profile, # XXX TODO: Remove following 4 vestigial params. 'followers_youknow': user_profile['followers_youknow'], 'followers_everybody': user_profile['followers_everybody'], 'following_youknow': user_profile['following_youknow'], 'following_everybody': user_profile['following_everybody'], 'profiles': dict([(p.user_id, p.to_json(compact=True)) for p in profiles]), 'activities': activities, } if include_activities_html: payload['activities_html'] = render_to_string('reader/activities_module.xhtml', { 'activities': activities, 'username': user_profile['username'], 'public': True, }) return payload
def load_activities(request): user_id = request.REQUEST.get('user_id', None) if user_id: user_id = int(user_id) user = User.objects.get(pk=user_id) else: user = get_user(request) user_id = user.pk public = user_id != request.user.pk page = max(1, int(request.REQUEST.get('page', 1))) limit = request.REQUEST.get('limit', 4) activities, has_next_page = MActivity.user(user_id, page=page, limit=limit, public=public) format = request.REQUEST.get('format', None) data = { 'activities': activities, 'page': page, 'has_next_page': has_next_page, 'username': (user.username if public else 'You'), } if format == 'html': return render_to_response('reader/activities_module.xhtml', data, context_instance=RequestContext(request)) else: return json.json_response(request, data)
def load_recommended_feed(request): user = get_user(request) page = int(request.REQUEST.get('page', 0)) usersub = None refresh = request.REQUEST.get('refresh') now = datetime.datetime.now unmoderated = request.REQUEST.get('unmoderated', False) == 'true' if unmoderated: recommended_feeds = RecommendedFeed.objects.filter(is_public=False, declined_date__isnull=True)[page:page+2] else: recommended_feeds = RecommendedFeed.objects.filter(is_public=True, approved_date__lte=now)[page:page+2] if recommended_feeds and request.user.is_authenticated(): usersub = UserSubscription.objects.filter(user=user, feed=recommended_feeds[0].feed) if refresh != 'true' and page > 0: logging.user(request, "~FBBrowse recommended feed: ~SBPage #%s" % (page+1)) recommended_feed = recommended_feeds and recommended_feeds[0] feed_icon = MFeedIcon.objects(feed_id=recommended_feed.feed.pk) if recommended_feed: return render_to_response('recommendations/render_recommended_feed.xhtml', { 'recommended_feed' : recommended_feed, 'description' : recommended_feed.description or recommended_feed.feed.data.feed_tagline, 'usersub' : usersub, 'feed_icon' : feed_icon and feed_icon[0], 'has_next_page' : len(recommended_feeds) > 1, 'has_previous_page' : page != 0, 'unmoderated' : unmoderated, 'today' : datetime.datetime.now(), }, context_instance=RequestContext(request)) else: return HttpResponse("")
def load_user_friends(request): user = get_user(request.user) social_profile, _ = MSocialProfile.objects.get_or_create(user_id=user.pk) social_services, _ = MSocialServices.objects.get_or_create(user_id=user.pk) following_profiles = MSocialProfile.profiles(social_profile.following_user_ids) follower_profiles = MSocialProfile.profiles(social_profile.follower_user_ids) recommended_users = social_profile.recommended_users() following_profiles = [p.to_json(include_following_user=user.pk) for p in following_profiles] follower_profiles = [p.to_json(include_following_user=user.pk) for p in follower_profiles] logging.user( request, "~BB~FRLoading Friends (%s following, %s followers)" % (social_profile.following_count, social_profile.follower_count), ) return { "services": social_services, "autofollow": social_services.autofollow, "user_profile": social_profile.to_json(include_follows=True), "following_profiles": following_profiles, "follower_profiles": follower_profiles, "recommended_users": recommended_users, }
def load_starred_stories(request): user = get_user(request) offset = int(request.REQUEST.get('offset', 0)) limit = int(request.REQUEST.get('limit', 10)) page = int(request.REQUEST.get('page', 0)) if page: offset = limit * (page - 1) mstories = MStarredStory.objects(user_id=user.pk).order_by('-starred_date')[offset:offset+limit] stories = Feed.format_stories(mstories) for story in stories: story_date = localtime_for_timezone(story['story_date'], user.profile.timezone) now = localtime_for_timezone(datetime.datetime.now(), user.profile.timezone) story['short_parsed_date'] = format_story_link_date__short(story_date, now) story['long_parsed_date'] = format_story_link_date__long(story_date, now) starred_date = localtime_for_timezone(story['starred_date'], user.profile.timezone) story['starred_date'] = format_story_link_date__long(starred_date, now) story['read_status'] = 1 story['starred'] = True story['intelligence'] = { 'feed': 0, 'author': 0, 'tags': 0, 'title': 0, } logging.user(request, "~FCLoading starred stories: ~SB%s stories" % (len(stories))) return dict(stories=stories)
def exception_retry(request): user = get_user(request) feed_id = request.POST['feed_id'] reset_fetch = json.decode(request.POST['reset_fetch']) feed = get_object_or_404(Feed, pk=feed_id) feed.next_scheduled_update = datetime.datetime.utcnow() feed.has_page_exception = False feed.has_feed_exception = False feed.active = True if reset_fetch: logging.user(request.user, "~FRRefreshing exception feed: ~SB%s" % (feed)) feed.fetched_once = False else: logging.user(request.user, "~FRForcing refreshing feed: ~SB%s" % (feed)) feed.fetched_once = True feed.save() feed = feed.update(force=True, compute_scores=False) usersub = UserSubscription.objects.get(user=user, feed=feed) usersub.calculate_feed_scores(silent=False) feeds = {feed.pk: usersub.canonical(full=True)} return {'code': 1, 'feeds': feeds}
def more_like_this(request): user = get_user(request) get_post = getattr(request, request.method) order = get_post.get('order', 'newest') page = int(get_post.get('page', 1)) limit = int(get_post.get('limit', 10)) offset = limit * (page - 1) story_hash = get_post.get('story_hash') feed_ids = [ us.feed_id for us in UserSubscription.objects.filter(user=user) ] feed_ids, _ = MStory.split_story_hash(story_hash) story_ids = SearchStory.more_like_this([feed_ids], story_hash, order, offset=offset, limit=limit) stories_db = MStory.objects(story_hash__in=story_ids).order_by( '-story_date' if order == "newest" else 'story_date') stories = Feed.format_stories(stories_db) return { "stories": stories, }
def load_recommended_feed(request): user = get_user(request) page = int(request.REQUEST.get('page', 0)) usersub = None recommended_feeds = RecommendedFeed.objects.all()[page:page + 2] if recommended_feeds: usersub = UserSubscription.objects.filter( user=user, feed=recommended_feeds[0].feed) if page != 0: logging.user(request.user, "~FBBrowse recommended feed: ~SBPage #%s" % (page + 1)) recommended_feed = recommended_feeds and recommended_feeds[0] if recommended_feed: return render_to_response( 'recommendations/render_recommended_feed.xhtml', { 'recommended_feed': recommended_feed, 'description': recommended_feed.description or recommended_feed.feed.data.feed_tagline, 'usersub': usersub, 'has_next_page': len(recommended_feeds) > 1, 'has_previous_page': page != 0, }, context_instance=RequestContext(request)) else: return HttpResponse("")
def render_dashboard_river(context, dashboard_river): user = get_user(context['user']) return { 'user': user, 'dashboard_river': dashboard_river, }
def render_dashboard_rivers_right(context, dashboard_rivers): user = get_user(context['user']) return { 'user': user, 'dashboard_rivers': dashboard_rivers, 'side': 'right' }
def load_feed_statistics(request, feed_id): user = get_user(request) feed = get_object_or_404(Feed, pk=feed_id) stats = assemble_statistics(user, feed_id) logging.user(request, "~FBStatistics: ~SB%s" % (feed)) return stats
def render_recommended_users(context): user = get_user(context['user']) profile = MSocialProfile.profile(user.pk) return { 'user': user, 'profile': profile, }
def load_feed_statistics(request, feed_id): user = get_user(request) stats = dict() feed = get_object_or_404(Feed, pk=feed_id) feed.update_all_statistics() feed.set_next_scheduled_update(verbose=True, skip_scheduling=True) feed.save_feed_story_history_statistics() feed.save_classifier_counts() # Dates of last and next update stats['active'] = feed.active stats['last_update'] = relative_timesince(feed.last_update) stats['next_update'] = relative_timeuntil(feed.next_scheduled_update) stats['push'] = feed.is_push # Minutes between updates update_interval_minutes = feed.get_next_scheduled_update(force=True, verbose=False) stats['update_interval_minutes'] = update_interval_minutes original_active_premium_subscribers = feed.active_premium_subscribers original_premium_subscribers = feed.premium_subscribers feed.active_premium_subscribers = max(feed.active_premium_subscribers + 1, 1) feed.premium_subscribers += 1 premium_update_interval_minutes = feed.get_next_scheduled_update( force=True, verbose=False) feed.active_premium_subscribers = original_active_premium_subscribers feed.premium_subscribers = original_premium_subscribers stats['premium_update_interval_minutes'] = premium_update_interval_minutes stats['errors_since_good'] = feed.errors_since_good # Stories per month - average and month-by-month breakout average_stories_per_month, story_count_history = feed.average_stories_per_month, feed.data.story_count_history stats['average_stories_per_month'] = average_stories_per_month stats['story_count_history'] = story_count_history and json.decode( story_count_history) # Subscribers stats['subscriber_count'] = feed.num_subscribers stats['stories_last_month'] = feed.stories_last_month stats['last_load_time'] = feed.last_load_time stats['premium_subscribers'] = feed.premium_subscribers stats['active_subscribers'] = feed.active_subscribers stats['active_premium_subscribers'] = feed.active_premium_subscribers # Classifier counts stats['classifier_counts'] = json.decode(feed.data.feed_classifier_counts) # Fetch histories timezone = user.profile.timezone fetch_history = MFetchHistory.feed(feed_id, timezone=timezone) stats['feed_fetch_history'] = fetch_history['feed_fetch_history'] stats['page_fetch_history'] = fetch_history['page_fetch_history'] stats['feed_push_history'] = fetch_history['push_history'] logging.user(request, "~FBStatistics: ~SB%s" % (feed)) return stats
def load_feeds(request): user = get_user(request) feeds = {} not_yet_fetched = False try: folders = UserSubscriptionFolders.objects.get(user=user) except UserSubscriptionFolders.DoesNotExist: data = dict(feeds=[], folders=[]) return data except UserSubscriptionFolders.MultipleObjectsReturned: UserSubscriptionFolders.objects.filter(user=user)[1:].delete() folders = UserSubscriptionFolders.objects.get(user=user) user_subs = UserSubscription.objects.select_related('feed', 'feed__feed_icon').filter(user=user) for sub in user_subs: feeds[sub.feed.pk] = { 'id': sub.feed.pk, 'feed_title': sub.user_title or sub.feed.feed_title, 'feed_address': sub.feed.feed_address, 'feed_link': sub.feed.feed_link, 'ps': sub.unread_count_positive, 'nt': sub.unread_count_neutral, 'ng': sub.unread_count_negative, 'updated': relative_timesince(sub.feed.last_update), 'subs': sub.feed.num_subscribers, 'active': sub.active, 'favicon': sub.feed.icon.data, 'favicon_color': sub.feed.icon.color, 'favicon_fetching': bool(not (sub.feed.icon.not_found or sub.feed.icon.data)) } if not sub.feed.fetched_once: not_yet_fetched = True feeds[sub.feed.pk]['not_yet_fetched'] = True if sub.feed.has_page_exception or sub.feed.has_feed_exception: feeds[sub.feed.pk]['has_exception'] = True feeds[sub.feed.pk]['exception_type'] = 'feed' if sub.feed.has_feed_exception else 'page' feeds[sub.feed.pk]['feed_address'] = sub.feed.feed_address feeds[sub.feed.pk]['exception_code'] = sub.feed.exception_code if not sub.feed.active and not sub.feed.has_feed_exception and not sub.feed.has_page_exception: sub.feed.count_subscribers() sub.feed.schedule_feed_fetch_immediately() if not_yet_fetched: for f in feeds: if 'not_yet_fetched' not in feeds[f]: feeds[f]['not_yet_fetched'] = False starred_count = MStarredStory.objects(user_id=user.pk).count() data = { 'feeds': feeds, 'folders': json.decode(folders.folders), 'starred_count': starred_count, } return data
def render_account_module(context): user = get_user(context["user"]) return { "user": user, "user_profile": user.profile, "social_profile": context["social_profile"], "feed_count": context["feed_count"], }
def refresh_feed(request, feed_id): user = get_user(request) feed = get_object_or_404(Feed, pk=feed_id) feed = feed.update(force=True, compute_scores=False) usersub = UserSubscription.objects.get(user=user, feed=feed) usersub.calculate_feed_scores(silent=False) return load_single_feed(request, feed_id)
def exception_retry(request): user = get_user(request) feed_id = get_argument_or_404(request, 'feed_id') reset_fetch = json.decode(request.POST['reset_fetch']) feed = Feed.get_by_id(feed_id) original_feed = feed if not feed: raise Http404 feed.schedule_feed_fetch_immediately() changed = False if feed.has_page_exception: changed = True feed.has_page_exception = False if feed.has_feed_exception: changed = True feed.has_feed_exception = False if not feed.active: changed = True feed.active = True if changed: feed.save(update_fields=[ 'has_page_exception', 'has_feed_exception', 'active' ]) original_fetched_once = feed.fetched_once if reset_fetch: logging.user(request, "~FRRefreshing exception feed: ~SB%s" % (feed)) feed.fetched_once = False else: logging.user(request, "~FRForcing refreshing feed: ~SB%s" % (feed)) feed.fetched_once = True if feed.fetched_once != original_fetched_once: feed.save(update_fields=['fetched_once']) feed = feed.update(force=True, compute_scores=False, verbose=True) feed = Feed.get_by_id(feed.pk) try: usersub = UserSubscription.objects.get(user=user, feed=feed) except UserSubscription.DoesNotExist: usersubs = UserSubscription.objects.filter(user=user, feed=original_feed) if usersubs: usersub = usersubs[0] usersub.switch_feed(feed, original_feed) else: return {'code': -1} usersub.calculate_feed_scores(silent=False) feeds = { feed.pk: usersub and usersub.canonical(full=True), feed_id: usersub.canonical(full=True) } return {'code': 1, 'feeds': feeds}
def get_classifiers_feed(request, feed_id): user = get_user(request) code = 0 payload = get_classifiers_for_user(user, feed_id=feed_id) response = dict(code=code, payload=payload) return response
def load_single_feed(request, feed_id): user = get_user(request) feed = get_object_or_404(Feed, pk=feed_id) classifiers = get_classifiers_for_user(user, feed_id=feed.pk) payload = feed.canonical(full=True) payload['classifiers'] = classifiers return payload
def render_getting_started(context): user = get_user(context['user']) profile = MSocialProfile.profile(user.pk) return { 'user': user, 'user_profile': user.profile, 'social_profile': profile, }
def render_account_module(context): user = get_user(context['user']) return { 'user': user, 'user_profile': user.profile, 'social_profile': context['social_profile'], 'feed_count': context['feed_count'], }
def load_single_feed(request, feed_id): user = get_user(request) feed = get_object_or_404(Feed, pk=feed_id) classifiers = get_classifiers_for_user(user, feed.pk) payload = feed.canonical(full=True) payload['classifiers'] = classifiers return payload
def render_feeds_skeleton(context): user = get_user(context['user']) social_profile = MSocialProfile.get_user(user.pk) return { 'user': user, 'social_profile': social_profile, 'MEDIA_URL': settings.MEDIA_URL, }
def force_push(request): user = get_user(request) feed_id = request.REQUEST['feed_id'] count = int(request.REQUEST.get('count', 1)) logging.user(user, "~BM~FWForce pushing %s stories: ~SB%s" % (count, Feed.get_by_id(feed_id))) sent_count, user_count = MUserFeedNotification.push_feed_notifications(feed_id, new_stories=count, force=True) return {"message": "Pushed %s notifications to %s users" % (sent_count, user_count)}
def load_features(request): user = get_user(request) page = int(request.REQUEST.get('page', 0)) logging.user(request, "~FBBrowse features: ~SBPage #%s" % (page+1)) features = Feature.objects.all()[page*3:(page+1)*3+1].values() features = [{ 'description': f['description'], 'date': localtime_for_timezone(f['date'], user.profile.timezone).strftime("%b %d, %Y") } for f in features] return features
def render_features_module(context): user = get_user(context['user']) features = Feature.objects.all()[:3] feature_form = FeatureForm() if user.is_staff else None return { 'user': user, 'features': features, 'feature_form': feature_form, }
def get_classifiers_feed(request): feed_id = int(request.POST['feed_id']) user = get_user(request) code = 0 payload = get_classifiers_for_user(user, feed_id) response = dict(code=code, payload=payload) return response
def refresh_feeds(request): start = datetime.datetime.utcnow() user = get_user(request) feed_ids = request.REQUEST.getlist('feed_id') feeds = {} user_subs = UserSubscription.objects.select_related('feed').filter(user=user, active=True) feed_ids = [f for f in feed_ids if f and not f.startswith('river')] if feed_ids: user_subs = user_subs.filter(feed__in=feed_ids) UNREAD_CUTOFF = datetime.datetime.utcnow() - datetime.timedelta(days=settings.DAYS_OF_UNREAD) favicons_fetching = [int(f) for f in request.REQUEST.getlist('favicons_fetching') if f] feed_icons = dict([(i.feed_id, i) for i in MFeedIcon.objects(feed_id__in=favicons_fetching)]) for i, sub in enumerate(user_subs): pk = sub.feed.pk if (sub.needs_unread_recalc or sub.unread_count_updated < UNREAD_CUTOFF or sub.oldest_unread_story_date < UNREAD_CUTOFF): sub = sub.calculate_feed_scores(silent=True) if not sub: continue # TODO: Figure out the correct sub and give it a new feed_id feeds[pk] = { 'ps': sub.unread_count_positive, 'nt': sub.unread_count_neutral, 'ng': sub.unread_count_negative, } if sub.feed.has_feed_exception or sub.feed.has_page_exception: feeds[pk]['has_exception'] = True feeds[pk]['exception_type'] = 'feed' if sub.feed.has_feed_exception else 'page' feeds[pk]['feed_address'] = sub.feed.feed_address feeds[pk]['exception_code'] = sub.feed.exception_code if request.REQUEST.get('check_fetch_status', False): feeds[pk]['not_yet_fetched'] = not sub.feed.fetched_once if sub.feed.pk in favicons_fetching and sub.feed.pk in feed_icons: feeds[pk]['favicon'] = feed_icons[sub.feed.pk].data feeds[pk]['favicon_color'] = feed_icons[sub.feed.pk].color feeds[pk]['favicon_fetching'] = sub.feed.favicon_fetching user_subs = UserSubscription.objects.select_related('feed').filter(user=user, active=True) if favicons_fetching: sub_feed_ids = [s.feed.pk for s in user_subs] moved_feed_ids = [f for f in favicons_fetching if f not in sub_feed_ids] for moved_feed_id in moved_feed_ids: duplicate_feeds = DuplicateFeed.objects.filter(duplicate_feed_id=moved_feed_id) if duplicate_feeds and duplicate_feeds[0].feed.pk in feeds: feeds[moved_feed_id] = feeds[duplicate_feeds[0].feed.pk] feeds[moved_feed_id]['dupe_feed_id'] = duplicate_feeds[0].feed.pk if settings.DEBUG or request.REQUEST.get('check_fetch_status'): diff = datetime.datetime.utcnow()-start timediff = float("%s.%.2s" % (diff.seconds, (diff.microseconds / 1000))) logging.user(request, "~FBRefreshing %s feeds (%s seconds) (%s/%s)" % (user_subs.count(), timediff, request.REQUEST.get('check_fetch_status', False), len(favicons_fetching))) return {'feeds': feeds}
def index(request): if request.method == "POST": if request.POST['submit'] == 'login': login_form = LoginForm(request.POST, prefix='login') signup_form = SignupForm(prefix='signup') else: login_form = LoginForm(prefix='login') signup_form = SignupForm(request.POST, prefix='signup') else: login_form = LoginForm(prefix='login') signup_form = SignupForm(prefix='signup') user = get_user(request) authed = request.user.is_authenticated() features = Feature.objects.all()[:3] feature_form = FeatureForm() if request.user.is_staff else None feed_count = UserSubscription.objects.filter( user=request.user).count() if authed else 0 active_count = UserSubscription.objects.filter( user=request.user, active=True).count() if authed else 0 train_count = UserSubscription.objects.filter( user=request.user, active=True, is_trained=False, feed__stories_last_month__gte=1).count() if authed else 0 recommended_feeds = RecommendedFeed.objects.filter( is_public=True, approved_date__lte=datetime.datetime.now()).select_related('feed')[:2] unmoderated_feeds = RecommendedFeed.objects.filter( is_public=False, declined_date__isnull=True).select_related('feed')[:2] statistics = MStatistics.all() feedbacks = MFeedback.all() start_import_from_google_reader = request.session.get( 'import_from_google_reader', False) if start_import_from_google_reader: del request.session['import_from_google_reader'] return render_to_response( 'reader/feeds.xhtml', { 'user_profile': hasattr(user, 'profile') and user.profile, 'login_form': login_form, 'signup_form': signup_form, 'feature_form': feature_form, 'features': features, 'feed_count': feed_count, 'active_count': active_count, 'train_count': active_count - train_count, 'account_images': range(1, 4), 'recommended_feeds': recommended_feeds, 'unmoderated_feeds': unmoderated_feeds, 'statistics': statistics, 'feedbacks': feedbacks, 'start_import_from_google_reader': start_import_from_google_reader, }, context_instance=RequestContext(request))
def feed_autocomplete(request): user = get_user(request) query = request.GET.get('term') version = int(request.GET.get('v', 1)) if not user.profile.is_premium: return dict(code=-1, message="Overloaded, no autocomplete results.") if not query: return dict(code=-1, message="Specify a search 'term'.") feeds = [] for field in ['feed_address', 'feed_title', 'feed_link']: if not feeds: feeds = Feed.objects.filter(**{ '%s__icontains' % field: query, 'num_subscribers__gt': 1, 'branch_from_feed__isnull': True, }).exclude( Q(**{'%s__icontains' % field: 'token'}) | Q(**{'%s__icontains' % field: 'private'}) ).only( 'id', 'feed_title', 'feed_address', 'num_subscribers' ).select_related("data").order_by('-num_subscribers')[:5] feeds = [{ 'id': feed.pk, 'value': feed.feed_address, 'label': feed.feed_title, 'tagline': feed.data and feed.data.feed_tagline, 'num_subscribers': feed.num_subscribers, } for feed in feeds] feed_ids = [f['id'] for f in feeds] feed_icons = dict((icon.feed_id, icon) for icon in MFeedIcon.objects.filter(feed_id__in=feed_ids)) for feed in feeds: if feed['id'] in feed_icons: feed_icon = feed_icons[feed['id']] if feed_icon.data: feed['favicon_color'] = feed_icon.color feed['favicon'] = feed_icon.data logging.user(request, "~FGAdd Search: ~SB%s ~SN(%s matches)" % (query, len(feeds),)) if version > 1: return { 'feeds': feeds, 'term': query, } else: return feeds
def load_feed_favicons(request): user = get_user(request) feed_ids = request.REQUEST.getlist('feed_ids') user_subs = UserSubscription.objects.select_related('feed').filter(user=user, active=True) if feed_ids and len(feed_ids) > 0: user_subs = user_subs.filter(feed__in=feed_ids) feed_ids = [sub['feed__pk'] for sub in user_subs.values('feed__pk')] feed_icons = dict([(i.feed_id, i.data) for i in MFeedIcon.objects(feed_id__in=feed_ids)]) return feed_icons
def load_feed_settings(request, feed_id): stats = dict() feed = get_object_or_404(Feed, pk=feed_id) user = get_user(request) timezone = user.profile.timezone stats['duplicate_addresses'] = feed.duplicate_addresses.all() stats['feed_fetch_history'] = MFeedFetchHistory.feed_history(feed_id, timezone=timezone) stats['page_fetch_history'] = MPageFetchHistory.feed_history(feed_id, timezone=timezone) return stats
def render_interactions_module(context, page=1): user = get_user(context['user']) interactions, has_next_page = MInteraction.user(user.pk, page) return { 'user': user, 'interactions': interactions, 'page': page, 'has_next_page': has_next_page, 'MEDIA_URL': context['MEDIA_URL'], }
def load_activities(request): user = get_user(request) page = max(1, int(request.REQUEST.get('page', 1))) activities, has_next_page = MActivity.user(user.pk, page=page) return { 'activities': activities, 'page': page, 'has_next_page': has_next_page, 'username': '******', }