Creates landing page views

bookwyrm/views/__init__.py

@@ -2,3 +2,4 @@
 from .authentication import Login, Register, Logout
 from .password import PasswordResetRequest, PasswordReset, ChangePassword
 from .invite import ManageInvites, Invite
+from .landing import About, Home, Feed, Discover

bookwyrm/views/helpers.py

@@ -0,0 +1,60 @@
+''' helper functions used in various views '''
+from django.db.models import Q
+from bookwyrm import models
+
+def get_activity_feed(
+        user, privacy, local_only=False, following_only=False,
+        queryset=models.Status.objects):
+    ''' get a filtered queryset of statuses '''
+    privacy = privacy if isinstance(privacy, list) else [privacy]
+    # if we're looking at Status, we need this. We don't if it's Comment
+    if hasattr(queryset, 'select_subclasses'):
+        queryset = queryset.select_subclasses()
+
+    # exclude deleted
+    queryset = queryset.exclude(deleted=True).order_by('-published_date')
+
+    # you can't see followers only or direct messages if you're not logged in
+    if user.is_anonymous:
+        privacy = [p for p in privacy if not p in ['followers', 'direct']]
+
+    # filter to only privided privacy levels
+    queryset = queryset.filter(privacy__in=privacy)
+
+    # only include statuses the user follows
+    if following_only:
+        queryset = queryset.exclude(
+            ~Q(# remove everythign except
+                Q(user__in=user.following.all()) | # user follwoing
+                Q(user=user) |# is self
+                Q(mention_users=user)# mentions user
+            ),
+        )
+    # exclude followers-only statuses the user doesn't follow
+    elif 'followers' in privacy:
+        queryset = queryset.exclude(
+            ~Q(# user isn't following and it isn't their own status
+                Q(user__in=user.following.all()) | Q(user=user)
+            ),
+            privacy='followers' # and the status is followers only
+        )
+
+    # exclude direct messages not intended for the user
+    if 'direct' in privacy:
+        queryset = queryset.exclude(
+            ~Q(
+                Q(user=user) | Q(mention_users=user)
+            ), privacy='direct'
+        )
+
+    # filter for only local status
+    if local_only:
+        queryset = queryset.filter(user__local=True)
+
+    # remove statuses that have boosts in the same queryset
+    try:
+        queryset = queryset.filter(~Q(boosters__in=queryset))
+    except ValueError:
+        pass
+
+    return queryset

bookwyrm/views/landing.py

@@ -0,0 +1,133 @@
+''' non-interactive pages '''
+from django.contrib.auth.decorators import login_required
+from django.core.paginator import Paginator
+from django.db.models import Avg, Max
+from django.template.response import TemplateResponse
+from django.utils.decorators import method_decorator
+from django.views import View
+
+from bookwyrm import forms, models
+from bookwyrm.settings import PAGE_LENGTH
+from .helpers import get_activity_feed
+
+
+# pylint: disable= no-self-use
+@method_decorator(login_required, name='dispatch')
+class About(View):
+    ''' create invites '''
+    def get(self, request):
+        ''' more information about the instance '''
+        data = {
+            'title': 'About',
+        }
+        return TemplateResponse(request, 'about.html', data)
+
+class Home(View):
+    ''' discover page or home feed depending on auth '''
+    def get(self, request):
+        ''' this is the same as the feed on the home tab '''
+        if request.user.is_authenticated:
+            feed_view = Feed.as_view()
+            return feed_view(request, 'home')
+        discover_view = Discover.as_view()
+        return discover_view(request)
+
+class Discover(View):
+    ''' preview of recently reviewed books '''
+    def get(self, request):
+        ''' tiled book activity page '''
+        books = models.Edition.objects.filter(
+            review__published_date__isnull=False,
+            review__user__local=True,
+            review__privacy__in=['public', 'unlisted'],
+        ).exclude(
+            cover__exact=''
+        ).annotate(
+            Max('review__published_date')
+        ).order_by('-review__published_date__max')[:6]
+
+        ratings = {}
+        for book in books:
+            reviews = models.Review.objects.filter(
+                book__in=book.parent_work.editions.all()
+            )
+            reviews = get_activity_feed(
+                request.user, ['public', 'unlisted'], queryset=reviews)
+            ratings[book.id] = reviews.aggregate(Avg('rating'))['rating__avg']
+        data = {
+            'title': 'Discover',
+            'register_form': forms.RegisterForm(),
+            'books': list(set(books)),
+            'ratings': ratings
+        }
+        return TemplateResponse(request, 'discover.html', data)
+
+
+@method_decorator(login_required, name='dispatch')
+class Feed(View):
+    ''' activity stream '''
+    def get(self, request, tab):
+        ''' user's homepage with activity feed '''
+        try:
+            page = int(request.GET.get('page', 1))
+        except ValueError:
+            page = 1
+
+        suggested_books = get_suggested_books(request.user)
+
+        if tab == 'home':
+            activities = get_activity_feed(
+                request.user, ['public', 'unlisted', 'followers'],
+                following_only=True)
+        elif tab == 'local':
+            activities = get_activity_feed(
+                request.user, ['public', 'followers'], local_only=True)
+        else:
+            activities = get_activity_feed(
+                request.user, ['public', 'followers'])
+        paginated = Paginator(activities, PAGE_LENGTH)
+        activity_page = paginated.page(page)
+
+        prev_page = next_page = None
+        if activity_page.has_next():
+            next_page = '/%s/?page=%d#feed' % \
+                    (tab, activity_page.next_page_number())
+        if activity_page.has_previous():
+            prev_page = '/%s/?page=%d#feed' % \
+                    (tab, activity_page.previous_page_number())
+        data = {
+            'title': 'Updates Feed',
+            'user': request.user,
+            'suggested_books': suggested_books,
+            'activities': activity_page.object_list,
+            'tab': tab,
+            'next': next_page,
+            'prev': prev_page,
+        }
+        return TemplateResponse(request, 'feed.html', data)
+
+
+def get_suggested_books(user, max_books=5):
+    ''' helper to get a user's recent books '''
+    book_count = 0
+    preset_shelves = [
+        ('reading', max_books), ('read', 2), ('to-read', max_books)
+    ]
+    suggested_books = []
+    for (preset, shelf_max) in preset_shelves:
+        limit = shelf_max if shelf_max < (max_books - book_count) \
+                else max_books - book_count
+        shelf = user.shelf_set.get(identifier=preset)
+
+        shelf_books = shelf.shelfbook_set.order_by(
+            '-updated_date'
+        ).all()[:limit]
+        if not shelf_books:
+            continue
+        shelf_preview = {
+            'name': shelf.name,
+            'books': [s.book for s in shelf_books]
+        }
+        suggested_books.append(shelf_preview)
+        book_count += len(shelf_preview['books'])
+    return suggested_books