2020-02-22 22:02:03 +00:00
|
|
|
''' views for pages you can go to in the application '''
|
2020-05-04 04:13:43 +00:00
|
|
|
import re
|
|
|
|
|
2020-10-01 19:59:38 +00:00
|
|
|
from django.contrib.auth.decorators import login_required, permission_required
|
2020-10-14 17:04:03 +00:00
|
|
|
from django.contrib.postgres.search import TrigramSimilarity
|
2020-11-11 18:35:34 +00:00
|
|
|
from django.core.paginator import Paginator
|
2020-11-07 04:51:11 +00:00
|
|
|
from django.db.models import Avg, Q
|
2020-12-12 00:39:58 +00:00
|
|
|
from django.http import HttpResponseNotFound, JsonResponse
|
2020-04-21 14:09:21 +00:00
|
|
|
from django.core.exceptions import PermissionDenied
|
2020-11-11 06:06:06 +00:00
|
|
|
from django.shortcuts import get_object_or_404, redirect
|
2020-01-25 23:25:19 +00:00
|
|
|
from django.template.response import TemplateResponse
|
2020-03-14 00:57:36 +00:00
|
|
|
from django.views.decorators.csrf import csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
from django.views.decorators.http import require_GET
|
2020-01-25 06:32:41 +00:00
|
|
|
|
2020-09-21 15:10:37 +00:00
|
|
|
from bookwyrm import outgoing
|
|
|
|
from bookwyrm.activitypub import ActivityEncoder
|
|
|
|
from bookwyrm import forms, models, books_manager
|
|
|
|
from bookwyrm import goodreads_import
|
2020-11-11 18:35:34 +00:00
|
|
|
from bookwyrm.settings import PAGE_LENGTH
|
2020-09-21 15:10:37 +00:00
|
|
|
from bookwyrm.tasks import app
|
2020-11-01 18:42:48 +00:00
|
|
|
from bookwyrm.utils import regex
|
2020-01-28 19:45:27 +00:00
|
|
|
|
|
|
|
|
2020-02-22 22:02:03 +00:00
|
|
|
def get_user_from_username(username):
|
|
|
|
''' helper function to resolve a localname or a username to a user '''
|
|
|
|
try:
|
|
|
|
user = models.User.objects.get(localname=username)
|
|
|
|
except models.User.DoesNotExist:
|
|
|
|
user = models.User.objects.get(username=username)
|
|
|
|
return user
|
|
|
|
|
|
|
|
|
2020-03-14 00:57:36 +00:00
|
|
|
def is_api_request(request):
|
|
|
|
''' check whether a request is asking for html or data '''
|
|
|
|
return 'json' in request.headers.get('Accept') or \
|
|
|
|
request.path[-5:] == '.json'
|
|
|
|
|
|
|
|
|
2020-03-29 23:05:33 +00:00
|
|
|
def server_error_page(request):
|
|
|
|
''' 500 errors '''
|
2020-11-02 22:25:16 +00:00
|
|
|
return TemplateResponse(request, 'error.html', {'title': 'Oops!'})
|
2020-03-29 23:05:33 +00:00
|
|
|
|
|
|
|
|
|
|
|
def not_found_page(request, _):
|
|
|
|
''' 404s '''
|
2020-11-02 22:25:16 +00:00
|
|
|
return TemplateResponse(request, 'notfound.html', {'title': 'Not found'})
|
2020-03-29 23:05:33 +00:00
|
|
|
|
|
|
|
|
2020-01-25 06:32:41 +00:00
|
|
|
@login_required
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-01-25 23:25:19 +00:00
|
|
|
def home(request):
|
2020-10-05 20:34:43 +00:00
|
|
|
''' this is the same as the feed on the home tab '''
|
|
|
|
return home_tab(request, 'home')
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-10-05 20:34:43 +00:00
|
|
|
def home_tab(request, tab):
|
2020-01-28 19:45:27 +00:00
|
|
|
''' user's homepage with activity feed '''
|
2020-04-01 22:36:35 +00:00
|
|
|
try:
|
|
|
|
page = int(request.GET.get('page', 1))
|
|
|
|
except ValueError:
|
|
|
|
page = 1
|
|
|
|
|
2020-11-07 18:56:03 +00:00
|
|
|
suggested_books = get_suggested_books(request.user)
|
2020-02-07 23:29:11 +00:00
|
|
|
|
2020-10-05 20:34:43 +00:00
|
|
|
activities = get_activity_feed(request.user, tab)
|
2020-11-11 18:35:34 +00:00
|
|
|
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())
|
2020-01-25 23:25:19 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Updates Feed',
|
2020-01-25 23:25:19 +00:00
|
|
|
'user': request.user,
|
2020-11-07 04:36:52 +00:00
|
|
|
'suggested_books': suggested_books,
|
2020-11-11 18:35:34 +00:00
|
|
|
'activities': activity_page.object_list,
|
2020-10-05 20:34:43 +00:00
|
|
|
'tab': tab,
|
2020-11-11 18:35:34 +00:00
|
|
|
'next': next_page,
|
|
|
|
'prev': prev_page,
|
2020-01-25 23:25:19 +00:00
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'feed.html', data)
|
2020-01-25 06:32:41 +00:00
|
|
|
|
2020-01-28 02:47:54 +00:00
|
|
|
|
2020-11-07 18:56:03 +00:00
|
|
|
def get_suggested_books(user, max_books=5):
|
|
|
|
''' helper to get a user's recent books '''
|
|
|
|
book_count = 0
|
2020-11-07 19:54:32 +00:00
|
|
|
preset_shelves = [
|
|
|
|
('reading', max_books), ('read', 2), ('to-read', max_books)
|
|
|
|
]
|
2020-11-07 18:56:03 +00:00
|
|
|
suggested_books = []
|
2020-11-07 19:54:32 +00:00
|
|
|
for (preset, shelf_max) in preset_shelves:
|
|
|
|
limit = shelf_max if shelf_max < (max_books - book_count) \
|
|
|
|
else max_books - book_count
|
2020-11-07 18:56:03 +00:00
|
|
|
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
|
|
|
|
|
|
|
|
|
2020-12-14 00:16:12 +00:00
|
|
|
@login_required
|
|
|
|
@require_GET
|
|
|
|
def direct_messages_page(request, page=1):
|
|
|
|
''' like a feed but for dms only '''
|
|
|
|
activities = get_activity_feed(request.user, 'direct')
|
|
|
|
paginated = Paginator(activities, PAGE_LENGTH)
|
|
|
|
activity_page = paginated.page(page)
|
|
|
|
|
|
|
|
prev_page = next_page = None
|
|
|
|
if activity_page.has_next():
|
|
|
|
next_page = '/direct-message/?page=%d#feed' % \
|
|
|
|
activity_page.next_page_number()
|
|
|
|
if activity_page.has_previous():
|
|
|
|
prev_page = '/direct-messages/?page=%d#feed' % \
|
|
|
|
activity_page.previous_page_number()
|
|
|
|
data = {
|
|
|
|
'title': 'Direct Messages',
|
|
|
|
'user': request.user,
|
|
|
|
'activities': activity_page.object_list,
|
|
|
|
'next': next_page,
|
|
|
|
'prev': prev_page,
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'direct_messages.html', data)
|
|
|
|
|
|
|
|
|
2020-04-01 23:02:39 +00:00
|
|
|
def get_activity_feed(user, filter_level, model=models.Status):
|
|
|
|
''' get a filtered queryset of statuses '''
|
2020-10-29 19:32:37 +00:00
|
|
|
if user.is_anonymous:
|
|
|
|
user = None
|
2020-12-14 00:16:12 +00:00
|
|
|
|
2020-10-29 19:32:37 +00:00
|
|
|
if user:
|
|
|
|
following = models.User.objects.filter(
|
|
|
|
Q(followers=user) | Q(id=user.id)
|
|
|
|
)
|
|
|
|
else:
|
|
|
|
following = []
|
2020-04-01 23:02:39 +00:00
|
|
|
|
|
|
|
activities = model
|
|
|
|
if hasattr(model, 'objects'):
|
2020-10-29 19:32:37 +00:00
|
|
|
activities = model.objects
|
2020-04-01 23:02:39 +00:00
|
|
|
|
2020-10-29 19:32:37 +00:00
|
|
|
activities = activities.filter(
|
2020-12-12 01:39:17 +00:00
|
|
|
deleted=False,
|
2020-10-29 19:32:37 +00:00
|
|
|
).order_by(
|
|
|
|
'-published_date'
|
2020-04-01 23:02:39 +00:00
|
|
|
)
|
2020-10-29 19:32:37 +00:00
|
|
|
|
2020-12-14 00:16:12 +00:00
|
|
|
if filter_level == 'direct':
|
|
|
|
return activities.filter(
|
|
|
|
Q(user=user) | Q(mention_users=user),
|
|
|
|
privacy='direct'
|
|
|
|
)
|
|
|
|
|
|
|
|
# never show DMs in the regular feed
|
|
|
|
activities = activities.filter(~Q(privacy='direct'))
|
|
|
|
|
|
|
|
|
2020-04-01 23:02:39 +00:00
|
|
|
if hasattr(activities, 'select_subclasses'):
|
|
|
|
activities = activities.select_subclasses()
|
|
|
|
|
|
|
|
if filter_level in ['friends', 'home']:
|
|
|
|
# people you follow and direct mentions
|
|
|
|
activities = activities.filter(
|
2020-10-29 19:32:37 +00:00
|
|
|
Q(user__in=following, privacy__in=[
|
|
|
|
'public', 'unlisted', 'followers'
|
|
|
|
]) | Q(mention_users=user) | Q(user=user)
|
2020-04-01 23:02:39 +00:00
|
|
|
)
|
|
|
|
elif filter_level == 'self':
|
|
|
|
activities = activities.filter(user=user, privacy='public')
|
|
|
|
elif filter_level == 'local':
|
2020-10-27 22:41:53 +00:00
|
|
|
# everyone on this instance except unlisted
|
|
|
|
activities = activities.filter(
|
|
|
|
Q(user__in=following, privacy='followers') | Q(privacy='public'),
|
|
|
|
user__local=True
|
|
|
|
)
|
2020-04-01 23:02:39 +00:00
|
|
|
else:
|
|
|
|
# all activities from everyone you federate with
|
2020-10-27 22:41:53 +00:00
|
|
|
activities = activities.filter(
|
|
|
|
Q(user__in=following, privacy='followers') | Q(privacy='public')
|
|
|
|
)
|
2020-04-01 23:02:39 +00:00
|
|
|
|
2020-12-12 01:39:17 +00:00
|
|
|
try:
|
|
|
|
activities = activities.filter(~Q(boosters__in=activities))
|
|
|
|
except ValueError:
|
|
|
|
pass
|
|
|
|
|
2020-04-01 23:02:39 +00:00
|
|
|
return activities
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-05-04 04:13:43 +00:00
|
|
|
def search(request):
|
|
|
|
''' that search bar up top '''
|
|
|
|
query = request.GET.get('q')
|
2020-05-04 17:15:41 +00:00
|
|
|
|
|
|
|
if is_api_request(request):
|
2020-10-14 16:19:23 +00:00
|
|
|
# only return local book results via json so we don't cause a cascade
|
|
|
|
book_results = books_manager.local_search(query)
|
|
|
|
return JsonResponse([r.__dict__ for r in book_results], safe=False)
|
2020-05-04 04:13:43 +00:00
|
|
|
|
2020-11-11 06:06:06 +00:00
|
|
|
# use webfinger for mastodon style account@domain.com username
|
2020-11-01 18:42:48 +00:00
|
|
|
if re.match(regex.full_username, query):
|
2020-10-14 16:54:07 +00:00
|
|
|
outgoing.handle_remote_webfinger(query)
|
|
|
|
|
|
|
|
# do a local user search
|
|
|
|
user_results = models.User.objects.annotate(
|
2020-10-14 17:04:03 +00:00
|
|
|
similarity=TrigramSimilarity('username', query),
|
2020-10-14 16:54:07 +00:00
|
|
|
).filter(
|
2020-11-11 06:06:06 +00:00
|
|
|
similarity__gt=0.5,
|
2020-10-14 17:04:03 +00:00
|
|
|
).order_by('-similarity')[:10]
|
2020-10-14 16:19:23 +00:00
|
|
|
|
|
|
|
book_results = books_manager.search(query)
|
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Search Results',
|
2020-10-14 16:19:23 +00:00
|
|
|
'book_results': book_results,
|
|
|
|
'user_results': user_results,
|
|
|
|
'query': query,
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'search_results.html', data)
|
2020-05-04 04:13:43 +00:00
|
|
|
|
|
|
|
|
2020-03-23 16:40:09 +00:00
|
|
|
@login_required
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-23 16:40:09 +00:00
|
|
|
def import_page(request):
|
|
|
|
''' import history from goodreads '''
|
|
|
|
return TemplateResponse(request, 'import.html', {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Import Books',
|
2020-03-23 16:40:09 +00:00
|
|
|
'import_form': forms.ImportForm(),
|
2020-04-21 14:09:21 +00:00
|
|
|
'jobs': models.ImportJob.
|
|
|
|
objects.filter(user=request.user).order_by('-created_date'),
|
2020-04-28 13:59:48 +00:00
|
|
|
'limit': goodreads_import.MAX_ENTRIES,
|
2020-03-23 16:40:09 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
|
2020-04-21 14:09:21 +00:00
|
|
|
@login_required
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-04-21 14:09:21 +00:00
|
|
|
def import_status(request, job_id):
|
|
|
|
''' status of an import job '''
|
|
|
|
job = models.ImportJob.objects.get(id=job_id)
|
|
|
|
if job.user != request.user:
|
|
|
|
raise PermissionDenied
|
|
|
|
task = app.AsyncResult(job.task_id)
|
2020-11-12 21:52:57 +00:00
|
|
|
items = job.items.order_by('index').all()
|
|
|
|
failed_items = [i for i in items if i.fail_reason]
|
|
|
|
items = [i for i in items if not i.fail_reason]
|
2020-04-21 14:09:21 +00:00
|
|
|
return TemplateResponse(request, 'import_status.html', {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Import Status',
|
2020-04-21 14:09:21 +00:00
|
|
|
'job': job,
|
2020-11-12 21:52:57 +00:00
|
|
|
'items': items,
|
|
|
|
'failed_items': failed_items,
|
2020-04-21 14:09:21 +00:00
|
|
|
'task': task
|
|
|
|
})
|
|
|
|
|
2020-03-17 00:45:34 +00:00
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-15 21:15:36 +00:00
|
|
|
def login_page(request):
|
2020-01-25 23:25:19 +00:00
|
|
|
''' authentication '''
|
2020-10-01 03:47:26 +00:00
|
|
|
if request.user.is_authenticated:
|
|
|
|
return redirect('/')
|
2020-01-25 23:25:19 +00:00
|
|
|
# send user to the login page
|
2020-03-15 21:15:36 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Login',
|
2020-03-15 21:15:36 +00:00
|
|
|
'login_form': forms.LoginForm(),
|
|
|
|
'register_form': forms.RegisterForm(),
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'login.html', data)
|
2020-01-29 03:05:59 +00:00
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-06-01 18:54:08 +00:00
|
|
|
def about_page(request):
|
|
|
|
''' more information about the instance '''
|
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'About',
|
2020-06-01 18:54:08 +00:00
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'about.html', data)
|
|
|
|
|
2020-09-17 20:02:52 +00:00
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-10-02 20:32:19 +00:00
|
|
|
def password_reset_request(request):
|
|
|
|
''' invite management page '''
|
2020-11-06 00:48:15 +00:00
|
|
|
return TemplateResponse(
|
|
|
|
request,
|
|
|
|
'password_reset_request.html',
|
|
|
|
{'title': 'Reset Password'}
|
|
|
|
)
|
2020-10-02 20:32:19 +00:00
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-10-02 20:32:19 +00:00
|
|
|
def password_reset(request, code):
|
|
|
|
''' endpoint for sending invites '''
|
|
|
|
if request.user.is_authenticated:
|
|
|
|
return redirect('/')
|
|
|
|
try:
|
|
|
|
reset_code = models.PasswordReset.objects.get(code=code)
|
|
|
|
if not reset_code.valid():
|
|
|
|
raise PermissionDenied
|
|
|
|
except models.PasswordReset.DoesNotExist:
|
|
|
|
raise PermissionDenied
|
|
|
|
|
|
|
|
return TemplateResponse(
|
|
|
|
request,
|
|
|
|
'password_reset.html',
|
2020-11-02 22:25:16 +00:00
|
|
|
{'title': 'Reset Password', 'code': reset_code.code}
|
2020-10-02 20:32:19 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-06-01 21:34:45 +00:00
|
|
|
def invite_page(request, code):
|
2020-09-17 20:02:52 +00:00
|
|
|
''' endpoint for sending invites '''
|
2020-10-01 03:47:26 +00:00
|
|
|
if request.user.is_authenticated:
|
|
|
|
return redirect('/')
|
2020-06-01 21:34:45 +00:00
|
|
|
try:
|
|
|
|
invite = models.SiteInvite.objects.get(code=code)
|
|
|
|
if not invite.valid():
|
|
|
|
raise PermissionDenied
|
|
|
|
except models.SiteInvite.DoesNotExist:
|
|
|
|
raise PermissionDenied
|
|
|
|
|
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Join',
|
2020-06-01 21:34:45 +00:00
|
|
|
'register_form': forms.RegisterForm(),
|
|
|
|
'invite': invite,
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'invite.html', data)
|
|
|
|
|
2020-11-11 06:06:06 +00:00
|
|
|
|
2020-06-03 16:38:30 +00:00
|
|
|
@login_required
|
2020-10-01 19:59:38 +00:00
|
|
|
@permission_required('bookwyrm.create_invites', raise_exception=True)
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-06-03 16:38:30 +00:00
|
|
|
def manage_invites(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
''' invite management page '''
|
2020-06-03 16:38:30 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Invitations',
|
2020-06-03 16:38:30 +00:00
|
|
|
'invites': models.SiteInvite.objects.filter(user=request.user),
|
|
|
|
'form': forms.CreateInviteForm(),
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'manage_invites.html', data)
|
|
|
|
|
2020-06-01 18:54:08 +00:00
|
|
|
|
2020-03-10 20:31:57 +00:00
|
|
|
@login_required
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-07 22:50:29 +00:00
|
|
|
def notifications_page(request):
|
|
|
|
''' list notitications '''
|
2020-03-10 18:23:23 +00:00
|
|
|
notifications = request.user.notification_set.all() \
|
|
|
|
.order_by('-created_date')
|
2020-03-10 20:31:57 +00:00
|
|
|
unread = [n.id for n in notifications.filter(read=False)]
|
2020-03-07 22:50:29 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Notifications',
|
2020-03-10 18:23:23 +00:00
|
|
|
'notifications': notifications,
|
2020-03-10 20:31:57 +00:00
|
|
|
'unread': unread,
|
2020-03-07 22:50:29 +00:00
|
|
|
}
|
2020-03-10 18:23:23 +00:00
|
|
|
notifications.update(read=True)
|
2020-03-07 22:50:29 +00:00
|
|
|
return TemplateResponse(request, 'notifications.html', data)
|
|
|
|
|
2020-11-10 22:07:12 +00:00
|
|
|
|
2020-03-14 00:57:36 +00:00
|
|
|
@csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-11-10 22:07:12 +00:00
|
|
|
def user_page(request, username):
|
2020-01-26 20:14:27 +00:00
|
|
|
''' profile page for a user '''
|
2020-01-28 06:49:56 +00:00
|
|
|
try:
|
2020-02-22 00:03:05 +00:00
|
|
|
user = get_user_from_username(username)
|
2020-01-28 06:49:56 +00:00
|
|
|
except models.User.DoesNotExist:
|
2020-02-22 00:03:05 +00:00
|
|
|
return HttpResponseNotFound()
|
2020-01-28 06:49:56 +00:00
|
|
|
|
2020-03-14 00:57:36 +00:00
|
|
|
if is_api_request(request):
|
|
|
|
# we have a json request
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(user.to_activity(), encoder=ActivityEncoder)
|
2020-03-14 00:57:36 +00:00
|
|
|
# otherwise we're at a UI view
|
|
|
|
|
2020-11-11 18:43:47 +00:00
|
|
|
try:
|
|
|
|
page = int(request.GET.get('page', 1))
|
|
|
|
except ValueError:
|
|
|
|
page = 1
|
|
|
|
|
2020-11-11 18:14:04 +00:00
|
|
|
shelf_preview = []
|
|
|
|
|
|
|
|
# only show other shelves that should be visible
|
|
|
|
shelves = user.shelf_set
|
|
|
|
is_self = request.user.id == user.id
|
|
|
|
if not is_self:
|
|
|
|
follower = user.followers.filter(id=request.user.id).exists()
|
|
|
|
if follower:
|
|
|
|
shelves = shelves.filter(privacy__in=['public', 'followers'])
|
|
|
|
else:
|
|
|
|
shelves = shelves.filter(privacy='public')
|
|
|
|
|
|
|
|
for user_shelf in shelves.all():
|
2020-10-30 21:01:43 +00:00
|
|
|
if not user_shelf.books.count():
|
2020-09-30 02:44:00 +00:00
|
|
|
continue
|
2020-11-11 18:14:04 +00:00
|
|
|
shelf_preview.append({
|
2020-10-30 21:01:43 +00:00
|
|
|
'name': user_shelf.name,
|
|
|
|
'remote_id': user_shelf.remote_id,
|
|
|
|
'books': user_shelf.books.all()[:3],
|
|
|
|
'size': user_shelf.books.count(),
|
2020-09-30 02:44:00 +00:00
|
|
|
})
|
2020-11-11 18:14:04 +00:00
|
|
|
if len(shelf_preview) > 2:
|
2020-09-30 02:44:00 +00:00
|
|
|
break
|
|
|
|
|
2020-11-11 18:43:47 +00:00
|
|
|
# user's posts
|
|
|
|
activities = get_activity_feed(user, 'self')
|
|
|
|
paginated = Paginator(activities, PAGE_LENGTH)
|
|
|
|
activity_page = paginated.page(page)
|
|
|
|
|
|
|
|
prev_page = next_page = None
|
|
|
|
if activity_page.has_next():
|
|
|
|
next_page = '/user/%s/?page=%d' % \
|
|
|
|
(username, activity_page.next_page_number())
|
|
|
|
if activity_page.has_previous():
|
|
|
|
prev_page = '/user/%s/?page=%d' % \
|
|
|
|
(username, activity_page.previous_page_number())
|
2020-11-11 06:06:06 +00:00
|
|
|
data = {
|
|
|
|
'title': user.name,
|
|
|
|
'user': user,
|
2020-11-11 18:14:04 +00:00
|
|
|
'is_self': is_self,
|
|
|
|
'shelves': shelf_preview,
|
|
|
|
'shelf_count': shelves.count(),
|
2020-11-11 18:43:47 +00:00
|
|
|
'activities': activity_page.object_list,
|
|
|
|
'next': next_page,
|
|
|
|
'prev': prev_page,
|
2020-11-11 06:06:06 +00:00
|
|
|
}
|
|
|
|
|
2020-04-22 13:53:22 +00:00
|
|
|
return TemplateResponse(request, 'user.html', data)
|
2020-01-26 20:14:27 +00:00
|
|
|
|
|
|
|
|
2020-03-14 00:57:36 +00:00
|
|
|
@csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-14 00:57:36 +00:00
|
|
|
def followers_page(request, username):
|
|
|
|
''' list of followers '''
|
|
|
|
try:
|
|
|
|
user = get_user_from_username(username)
|
|
|
|
except models.User.DoesNotExist:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
|
|
|
if is_api_request(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(user.to_followers_activity(**request.GET))
|
2020-03-14 00:57:36 +00:00
|
|
|
|
2020-11-10 22:07:12 +00:00
|
|
|
data = {
|
|
|
|
'title': '%s: followers' % user.name,
|
|
|
|
'user': user,
|
|
|
|
'is_self': request.user.id == user.id,
|
|
|
|
'followers': user.followers.all(),
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'followers.html', data)
|
2020-03-14 00:57:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
@csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-14 00:57:36 +00:00
|
|
|
def following_page(request, username):
|
|
|
|
''' list of followers '''
|
|
|
|
try:
|
|
|
|
user = get_user_from_username(username)
|
|
|
|
except models.User.DoesNotExist:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
|
|
|
if is_api_request(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(user.to_following_activity(**request.GET))
|
2020-03-14 00:57:36 +00:00
|
|
|
|
2020-11-10 22:07:12 +00:00
|
|
|
data = {
|
|
|
|
'title': '%s: following' % user.name,
|
|
|
|
'user': user,
|
|
|
|
'is_self': request.user.id == user.id,
|
|
|
|
'following': user.following.all(),
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'following.html', data)
|
2020-03-14 00:57:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
@csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-07 23:28:11 +00:00
|
|
|
def status_page(request, username, status_id):
|
|
|
|
''' display a particular status (and replies, etc) '''
|
|
|
|
try:
|
2020-03-10 18:28:11 +00:00
|
|
|
user = get_user_from_username(username)
|
2020-03-07 23:28:11 +00:00
|
|
|
status = models.Status.objects.select_subclasses().get(id=status_id)
|
|
|
|
except ValueError:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
2020-10-27 22:41:53 +00:00
|
|
|
# the url should have the poster's username in it
|
2020-03-07 23:28:11 +00:00
|
|
|
if user != status.user:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
2020-10-27 22:41:53 +00:00
|
|
|
# make sure the user is authorized to see the status
|
|
|
|
if not status_visible_to_user(request.user, status):
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
2020-03-14 00:57:36 +00:00
|
|
|
if is_api_request(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(status.to_activity(), encoder=ActivityEncoder)
|
2020-03-14 00:57:36 +00:00
|
|
|
|
2020-03-07 23:28:11 +00:00
|
|
|
data = {
|
2020-11-06 23:14:30 +00:00
|
|
|
'title': 'Status by %s' % user.username,
|
2020-03-07 23:28:11 +00:00
|
|
|
'status': status,
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'status.html', data)
|
|
|
|
|
2020-11-11 06:06:06 +00:00
|
|
|
|
2020-10-27 22:41:53 +00:00
|
|
|
def status_visible_to_user(viewer, status):
|
|
|
|
''' is a user authorized to view a status? '''
|
|
|
|
if viewer == status.user or status.privacy in ['public', 'unlisted']:
|
|
|
|
return True
|
|
|
|
if status.privacy == 'followers' and \
|
|
|
|
status.user.followers.filter(id=viewer.id).first():
|
|
|
|
return True
|
|
|
|
if status.privacy == 'direct' and \
|
|
|
|
status.mention_users.filter(id=viewer.id).first():
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
2020-03-14 00:57:36 +00:00
|
|
|
@csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-14 00:57:36 +00:00
|
|
|
def replies_page(request, username, status_id):
|
|
|
|
''' ordered collection of replies to a status '''
|
|
|
|
if not is_api_request(request):
|
|
|
|
return status_page(request, username, status_id)
|
|
|
|
|
|
|
|
status = models.Status.objects.get(id=status_id)
|
|
|
|
if status.user.localname != username:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(
|
|
|
|
status.to_replies(**request.GET),
|
|
|
|
encoder=ActivityEncoder
|
|
|
|
)
|
2020-03-14 00:57:36 +00:00
|
|
|
|
|
|
|
|
2020-01-28 06:49:56 +00:00
|
|
|
@login_required
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-03-08 16:39:59 +00:00
|
|
|
def edit_profile_page(request):
|
2020-01-28 06:49:56 +00:00
|
|
|
''' profile page for a user '''
|
2020-03-08 16:39:59 +00:00
|
|
|
user = request.user
|
2020-01-28 06:49:56 +00:00
|
|
|
|
2020-01-29 20:24:50 +00:00
|
|
|
form = forms.EditUserForm(instance=request.user)
|
2020-01-28 06:49:56 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Edit profile',
|
2020-01-29 07:23:05 +00:00
|
|
|
'form': form,
|
2020-01-28 06:49:56 +00:00
|
|
|
'user': user,
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'edit_user.html', data)
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-09-30 23:00:41 +00:00
|
|
|
def book_page(request, book_id):
|
2020-01-28 02:47:54 +00:00
|
|
|
''' info about a book '''
|
2020-11-11 18:50:51 +00:00
|
|
|
try:
|
|
|
|
page = int(request.GET.get('page', 1))
|
|
|
|
except ValueError:
|
|
|
|
page = 1
|
|
|
|
|
2020-11-12 19:40:20 +00:00
|
|
|
try:
|
|
|
|
book = models.Book.objects.select_subclasses().get(id=book_id)
|
|
|
|
except models.Book.DoesNotExist:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
2020-03-28 02:52:05 +00:00
|
|
|
if is_api_request(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(book.to_activity(), encoder=ActivityEncoder)
|
2020-03-28 02:52:05 +00:00
|
|
|
|
2020-03-07 06:56:44 +00:00
|
|
|
if isinstance(book, models.Work):
|
2020-11-29 01:41:57 +00:00
|
|
|
book = book.get_default_edition()
|
2020-04-06 00:00:01 +00:00
|
|
|
if not book:
|
|
|
|
return HttpResponseNotFound()
|
2020-03-30 22:03:21 +00:00
|
|
|
|
|
|
|
work = book.parent_work
|
2020-04-04 20:12:15 +00:00
|
|
|
if not work:
|
|
|
|
return HttpResponseNotFound()
|
2020-03-30 21:12:18 +00:00
|
|
|
|
2020-09-30 23:00:41 +00:00
|
|
|
reviews = models.Review.objects.filter(
|
2020-11-29 01:29:03 +00:00
|
|
|
book__in=work.editions.all(),
|
2020-10-29 19:32:37 +00:00
|
|
|
)
|
2020-11-11 18:50:51 +00:00
|
|
|
# all reviews for the book
|
2020-10-29 19:32:37 +00:00
|
|
|
reviews = get_activity_feed(request.user, 'federated', model=reviews)
|
2020-03-07 06:56:44 +00:00
|
|
|
|
2020-11-11 18:50:51 +00:00
|
|
|
# the reviews to show
|
|
|
|
paginated = Paginator(reviews.filter(content__isnull=False), PAGE_LENGTH)
|
|
|
|
reviews_page = paginated.page(page)
|
|
|
|
|
|
|
|
prev_page = next_page = None
|
|
|
|
if reviews_page.has_next():
|
|
|
|
next_page = '/book/%d/?page=%d' % \
|
|
|
|
(book_id, reviews_page.next_page_number())
|
|
|
|
if reviews_page.has_previous():
|
|
|
|
prev_page = '/book/%s/?page=%d' % \
|
|
|
|
(book_id, reviews_page.previous_page_number())
|
|
|
|
|
2020-12-12 00:39:58 +00:00
|
|
|
user_tags = readthroughs = user_shelves = other_edition_shelves = []
|
2020-03-27 15:05:27 +00:00
|
|
|
if request.user.is_authenticated:
|
2020-11-28 19:00:40 +00:00
|
|
|
user_tags = models.UserTag.objects.filter(
|
2020-03-27 15:05:27 +00:00
|
|
|
book=book, user=request.user
|
2020-11-28 19:00:40 +00:00
|
|
|
).values_list('tag__identifier', flat=True)
|
2020-02-23 22:26:03 +00:00
|
|
|
|
2020-10-29 19:32:37 +00:00
|
|
|
readthroughs = models.ReadThrough.objects.filter(
|
2020-10-29 21:29:31 +00:00
|
|
|
user=request.user,
|
|
|
|
book=book,
|
2020-10-29 19:32:37 +00:00
|
|
|
).order_by('start_date')
|
|
|
|
|
2020-12-12 00:39:58 +00:00
|
|
|
user_shelves = models.ShelfBook.objects.filter(
|
|
|
|
added_by=request.user, book=book
|
|
|
|
)
|
|
|
|
|
|
|
|
other_edition_shelves = models.ShelfBook.objects.filter(
|
|
|
|
~Q(book=book),
|
|
|
|
added_by=request.user,
|
|
|
|
book__parent_work=book.parent_work,
|
|
|
|
)
|
|
|
|
|
2020-01-28 02:47:54 +00:00
|
|
|
rating = reviews.aggregate(Avg('rating'))
|
2020-11-28 19:00:40 +00:00
|
|
|
tags = models.UserTag.objects.filter(
|
|
|
|
book=book,
|
|
|
|
)
|
2020-02-21 06:19:19 +00:00
|
|
|
|
2020-01-28 02:47:54 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': book.title,
|
2020-01-28 02:47:54 +00:00
|
|
|
'book': book,
|
2020-11-11 18:50:51 +00:00
|
|
|
'reviews': reviews_page,
|
2020-09-30 23:00:41 +00:00
|
|
|
'ratings': reviews.filter(content__isnull=True),
|
2020-01-28 02:47:54 +00:00
|
|
|
'rating': rating['rating__avg'],
|
2020-02-21 06:19:19 +00:00
|
|
|
'tags': tags,
|
|
|
|
'user_tags': user_tags,
|
2020-12-12 00:39:58 +00:00
|
|
|
'user_shelves': user_shelves,
|
|
|
|
'other_edition_shelves': other_edition_shelves,
|
2020-10-30 05:38:01 +00:00
|
|
|
'readthroughs': readthroughs,
|
2020-05-04 00:53:14 +00:00
|
|
|
'path': '/book/%s' % book_id,
|
2020-04-02 02:38:07 +00:00
|
|
|
'info_fields': [
|
2020-04-29 17:09:14 +00:00
|
|
|
{'name': 'ISBN', 'value': book.isbn_13},
|
2020-04-02 02:38:07 +00:00
|
|
|
{'name': 'OCLC number', 'value': book.oclc_number},
|
|
|
|
{'name': 'OpenLibrary ID', 'value': book.openlibrary_key},
|
|
|
|
{'name': 'Goodreads ID', 'value': book.goodreads_key},
|
|
|
|
{'name': 'Format', 'value': book.physical_format},
|
|
|
|
{'name': 'Pages', 'value': book.pages},
|
|
|
|
],
|
2020-11-11 18:50:51 +00:00
|
|
|
'next': next_page,
|
|
|
|
'prev': prev_page,
|
2020-01-28 02:47:54 +00:00
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'book.html', data)
|
|
|
|
|
|
|
|
|
2020-03-28 22:06:16 +00:00
|
|
|
@login_required
|
2020-10-01 19:59:38 +00:00
|
|
|
@permission_required('bookwyrm.edit_book', raise_exception=True)
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-05-04 00:53:14 +00:00
|
|
|
def edit_book_page(request, book_id):
|
2020-03-28 22:06:16 +00:00
|
|
|
''' info about a book '''
|
2020-05-11 01:08:18 +00:00
|
|
|
book = books_manager.get_edition(book_id)
|
2020-04-04 20:46:10 +00:00
|
|
|
if not book.description:
|
|
|
|
book.description = book.parent_work.description
|
2020-03-28 22:06:16 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Edit Book',
|
2020-03-28 22:06:16 +00:00
|
|
|
'book': book,
|
2020-04-02 15:44:53 +00:00
|
|
|
'form': forms.EditionForm(instance=book)
|
2020-03-28 22:06:16 +00:00
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'edit_book.html', data)
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-11-04 20:55:00 +00:00
|
|
|
def editions_page(request, book_id):
|
2020-03-30 22:03:21 +00:00
|
|
|
''' list of editions of a book '''
|
2020-11-11 06:06:06 +00:00
|
|
|
work = get_object_or_404(models.Work, id=book_id)
|
2020-11-04 20:55:00 +00:00
|
|
|
|
|
|
|
if is_api_request(request):
|
|
|
|
return JsonResponse(
|
|
|
|
work.to_edition_list(**request.GET),
|
|
|
|
encoder=ActivityEncoder
|
|
|
|
)
|
|
|
|
|
2020-03-30 22:03:21 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': 'Editions of %s' % work.title,
|
2020-12-16 17:15:26 +00:00
|
|
|
'editions': work.editions.all(),
|
2020-03-30 22:03:21 +00:00
|
|
|
'work': work,
|
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'editions.html', data)
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-05-04 00:53:14 +00:00
|
|
|
def author_page(request, author_id):
|
2020-02-11 06:32:03 +00:00
|
|
|
''' landing page for an author '''
|
2020-11-11 06:06:06 +00:00
|
|
|
author = get_object_or_404(models.Author, id=author_id)
|
2020-02-11 06:32:03 +00:00
|
|
|
|
2020-05-09 19:09:40 +00:00
|
|
|
if is_api_request(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(author.to_activity(), encoder=ActivityEncoder)
|
2020-05-09 19:09:40 +00:00
|
|
|
|
2020-03-30 22:03:21 +00:00
|
|
|
books = models.Work.objects.filter(authors=author)
|
2020-02-11 06:32:03 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': author.name,
|
2020-02-11 06:32:03 +00:00
|
|
|
'author': author,
|
2020-11-29 01:41:57 +00:00
|
|
|
'books': [b.get_default_edition() for b in books],
|
2020-02-11 06:32:03 +00:00
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'author.html', data)
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-02-21 17:10:27 +00:00
|
|
|
def tag_page(request, tag_id):
|
|
|
|
''' books related to a tag '''
|
2020-02-21 17:15:20 +00:00
|
|
|
tag_obj = models.Tag.objects.filter(identifier=tag_id).first()
|
2020-09-17 20:02:52 +00:00
|
|
|
if not tag_obj:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
|
|
|
if is_api_request(request):
|
|
|
|
return JsonResponse(
|
|
|
|
tag_obj.to_activity(**request.GET), encoder=ActivityEncoder)
|
|
|
|
|
2020-11-28 19:00:40 +00:00
|
|
|
books = models.Edition.objects.filter(
|
|
|
|
usertag__tag__identifier=tag_id
|
|
|
|
).distinct()
|
2020-02-21 17:10:27 +00:00
|
|
|
data = {
|
2020-11-02 22:25:16 +00:00
|
|
|
'title': tag_obj.name,
|
2020-02-21 17:10:27 +00:00
|
|
|
'books': books,
|
2020-02-21 17:15:20 +00:00
|
|
|
'tag': tag_obj,
|
2020-02-21 17:10:27 +00:00
|
|
|
}
|
|
|
|
return TemplateResponse(request, 'tag.html', data)
|
|
|
|
|
|
|
|
|
2020-11-11 18:14:04 +00:00
|
|
|
@csrf_exempt
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-11-11 18:14:04 +00:00
|
|
|
def user_shelves_page(request, username):
|
|
|
|
''' list of followers '''
|
|
|
|
return shelf_page(request, username, None)
|
|
|
|
|
|
|
|
|
2020-11-28 16:22:25 +00:00
|
|
|
@require_GET
|
2020-02-22 00:03:05 +00:00
|
|
|
def shelf_page(request, username, shelf_identifier):
|
|
|
|
''' display a shelf '''
|
|
|
|
try:
|
|
|
|
user = get_user_from_username(username)
|
|
|
|
except models.User.DoesNotExist:
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
2020-11-10 22:52:04 +00:00
|
|
|
if shelf_identifier:
|
|
|
|
shelf = user.shelf_set.get(identifier=shelf_identifier)
|
|
|
|
else:
|
|
|
|
shelf = user.shelf_set.first()
|
|
|
|
|
2020-11-11 00:43:52 +00:00
|
|
|
is_self = request.user == user
|
|
|
|
|
|
|
|
shelves = user.shelf_set
|
|
|
|
if not is_self:
|
|
|
|
follower = user.followers.filter(id=request.user.id).exists()
|
|
|
|
# make sure the user has permission to view the shelf
|
|
|
|
if shelf.privacy == 'direct' or \
|
|
|
|
(shelf.privacy == 'followers' and not follower):
|
|
|
|
return HttpResponseNotFound()
|
|
|
|
|
|
|
|
# only show other shelves that should be visible
|
|
|
|
if follower:
|
|
|
|
shelves = shelves.filter(privacy__in=['public', 'followers'])
|
|
|
|
else:
|
|
|
|
shelves = shelves.filter(privacy='public')
|
|
|
|
|
|
|
|
|
2020-03-28 02:52:05 +00:00
|
|
|
if is_api_request(request):
|
2020-09-17 20:02:52 +00:00
|
|
|
return JsonResponse(shelf.to_activity(**request.GET))
|
2020-03-28 02:52:05 +00:00
|
|
|
|
2020-11-10 22:07:12 +00:00
|
|
|
data = {
|
|
|
|
'title': user.name,
|
|
|
|
'user': user,
|
2020-11-11 00:43:52 +00:00
|
|
|
'is_self': is_self,
|
|
|
|
'shelves': shelves.all(),
|
2020-11-10 22:52:04 +00:00
|
|
|
'shelf': shelf,
|
2020-11-10 22:07:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return TemplateResponse(request, 'shelf.html', data)
|