lib.itmens/books/views.py
2020-10-26 00:18:57 +01:00

581 lines
21 KiB
Python

import logging
from django.shortcuts import render, get_object_or_404, redirect, reverse
from django.contrib.auth.decorators import login_required, permission_required
from django.utils.translation import gettext_lazy as _
from django.http import HttpResponseBadRequest, HttpResponseServerError
from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
from django.db import IntegrityError, transaction
from django.db.models import Count
from django.utils import timezone
from django.core.paginator import Paginator
from django.core.files.uploadedfile import SimpleUploadedFile
from mastodon import mastodon_request_included
from mastodon.api import check_visibility, post_toot, TootVisibilityEnum
from mastodon.utils import rating_to_emoji
from common.utils import PageLinksGenerator
from common.views import PAGE_LINK_NUMBER
from .models import *
from .forms import *
from .forms import BookMarkStatusTranslator
from boofilsic.settings import MASTODON_TAGS
logger = logging.getLogger(__name__)
mastodon_logger = logging.getLogger("django.mastodon")
# how many marks showed on the detail page
MARK_NUMBER = 5
# how many marks at the mark page
MARK_PER_PAGE = 20
# how many reviews showed on the detail page
REVIEW_NUMBER = 5
# how many reviews at the mark page
REVIEW_PER_PAGE = 20
# max tags on detail page
TAG_NUMBER = 10
# public data
###########################
@login_required
def create(request):
if request.method == 'GET':
form = BookForm()
return render(
request,
'books/create_update.html',
{
'form': form,
'title': _('添加书籍'),
'submit_url': reverse("books:create")
}
)
elif request.method == 'POST':
if request.user.is_authenticated:
# only local user can alter public data
form = BookForm(request.POST, request.FILES)
if form.is_valid():
form.instance.last_editor = request.user
form.save()
return redirect(reverse("books:retrieve", args=[form.instance.id]))
else:
return render(
request,
'books/create_update.html',
{
'form': form,
'title': _('添加书籍'),
'submit_url': reverse("books:create")
}
)
else:
return redirect(reverse("users:login"))
else:
return HttpResponseBadRequest()
@login_required
def update(request, id):
if request.method == 'GET':
book = get_object_or_404(Book, pk=id)
form = BookForm(instance=book)
return render(
request,
'books/create_update.html',
{
'form': form,
'title': _('修改书籍'),
'submit_url': reverse("books:update", args=[book.id])
}
)
elif request.method == 'POST':
book = get_object_or_404(Book, pk=id)
form = BookForm(request.POST, request.FILES, instance=book)
if form.is_valid():
form.instance.last_editor = request.user
form.instance.edited_time = timezone.now()
form.save()
else:
return render(
request,
'books/create_update.html',
{
'form': form,
'title': _('修改书籍'),
'submit_url': reverse("books:update", args=[book.id])
}
)
return redirect(reverse("books:retrieve", args=[form.instance.id]))
else:
return HttpResponseBadRequest()
@mastodon_request_included
# @login_required
def retrieve(request, id):
if request.method == 'GET':
book = get_object_or_404(Book, pk=id)
mark = None
mark_tags = None
review = None
# retreive tags
book_tag_list = book.book_tags.values('content').annotate(
tag_frequency=Count('content')).order_by('-tag_frequency')[:TAG_NUMBER]
# retrieve user mark and initialize mark form
try:
if request.user.is_authenticated:
mark = BookMark.objects.get(owner=request.user, book=book)
except ObjectDoesNotExist:
mark = None
if mark:
mark_tags = mark.bookmark_tags.all()
mark.get_status_display = BookMarkStatusTranslator(mark.status)
mark_form = BookMarkForm(instance=mark, initial={
'tags': mark_tags
})
else:
mark_form = BookMarkForm(initial={
'book': book,
'tags': mark_tags
})
# retrieve user review
try:
if request.user.is_authenticated:
review = BookReview.objects.get(owner=request.user, book=book)
except ObjectDoesNotExist:
review = None
# retrieve other related reviews and marks
if request.user.is_anonymous:
# hide all marks and reviews for anonymous user
mark_list = None
review_list = None
mark_list_more = None
review_list_more = None
else:
mark_list = BookMark.get_available(
book, request.user, request.session['oauth_token'])
review_list = BookReview.get_available(
book, request.user, request.session['oauth_token'])
mark_list_more = True if len(mark_list) > MARK_NUMBER else False
mark_list = mark_list[:MARK_NUMBER]
for m in mark_list:
m.get_status_display = BookMarkStatusTranslator(m.status)
review_list_more = True if len(
review_list) > REVIEW_NUMBER else False
review_list = review_list[:REVIEW_NUMBER]
# def strip_html_tags(text):
# import re
# regex = re.compile('<.*?>')
# return re.sub(regex, '', text)
# for r in review_list:
# r.content = strip_html_tags(r.content)
return render(
request,
'books/detail.html',
{
'book': book,
'mark': mark,
'review': review,
'status_enum': MarkStatusEnum,
'mark_form': mark_form,
'mark_list': mark_list,
'mark_list_more': mark_list_more,
'review_list': review_list,
'review_list_more': review_list_more,
'book_tag_list': book_tag_list,
'mark_tags': mark_tags,
}
)
else:
logger.warning('non-GET method at /book/<id>')
return HttpResponseBadRequest()
@permission_required('books.delete_book')
@login_required
def delete(request, id):
if request.method == 'GET':
book = get_object_or_404(Book, pk=id)
return render(
request,
'books/delete.html',
{
'book': book,
}
)
elif request.method == 'POST':
if request.user.is_staff:
# only staff has right to delete
book = get_object_or_404(Book, pk=id)
book.delete()
return redirect(reverse("common:home"))
else:
raise PermissionDenied()
else:
return HttpResponseBadRequest()
# user owned entites
###########################
@mastodon_request_included
@login_required
def create_update_mark(request):
# check list:
# clean rating if is wish
# transaction on updating book rating
# owner check(guarantee)
if request.method == 'POST':
pk = request.POST.get('id')
old_rating = None
old_tags = None
if pk:
mark = get_object_or_404(BookMark, pk=pk)
if request.user != mark.owner:
return HttpResponseBadRequest()
old_rating = mark.rating
old_tags = mark.bookmark_tags.all()
# update
form = BookMarkForm(request.POST, instance=mark)
else:
# create
form = BookMarkForm(request.POST)
if form.is_valid():
if form.instance.status == MarkStatusEnum.WISH.value:
form.instance.rating = None
form.cleaned_data['rating'] = None
form.instance.owner = request.user
form.instance.edited_time = timezone.now()
book = form.instance.book
try:
with transaction.atomic():
# update book rating
book.update_rating(old_rating, form.instance.rating)
form.save()
# update tags
if old_tags:
for tag in old_tags:
tag.delete()
if form.cleaned_data['tags']:
for tag in form.cleaned_data['tags']:
BookTag.objects.create(
content=tag,
book=book,
mark=form.instance
)
except IntegrityError as e:
return HttpResponseServerError("integrity error")
logger.error(e.__str__())
if form.cleaned_data['share_to_mastodon']:
if form.cleaned_data['is_private']:
visibility = TootVisibilityEnum.PRIVATE
else:
visibility = TootVisibilityEnum.UNLISTED
url = "https://" + request.get_host() + reverse("books:retrieve",
args=[book.id])
words = BookMarkStatusTranslator(int(form.cleaned_data['status'])) +\
f"{book.title}" + \
rating_to_emoji(form.cleaned_data['rating'])
# tags = MASTODON_TAGS % {'category': '书', 'type': '标记'}
tags = ''
content = words + '\n' + url + '\n' + \
form.cleaned_data['text'] + '\n' + tags
response = post_toot(
request.user.mastodon_site, content, visibility, request.session['oauth_token'])
if response.status_code != 200:
mastodon_logger.error(f"CODE:{response.status_code} {response.text}")
return HttpResponseServerError("publishing mastodon status failed")
else:
return HttpResponseBadRequest("invalid form data")
return redirect(reverse("books:retrieve", args=[form.instance.book.id]))
else:
return HttpResponseBadRequest("invalid method")
@mastodon_request_included
@login_required
def retrieve_mark_list(request, book_id):
if request.method == 'GET':
book = get_object_or_404(Book, pk=book_id)
queryset = BookMark.get_available(
book, request.user, request.session['oauth_token'])
paginator = Paginator(queryset, MARK_PER_PAGE)
page_number = request.GET.get('page', default=1)
marks = paginator.get_page(page_number)
marks.pagination = PageLinksGenerator(
PAGE_LINK_NUMBER, page_number, paginator.num_pages)
for m in marks:
m.get_status_display = BookMarkStatusTranslator(m.status)
return render(
request,
'books/mark_list.html',
{
'marks': marks,
'book': book,
}
)
else:
return HttpResponseBadRequest()
@login_required
def delete_mark(request, id):
if request.method == 'POST':
mark = get_object_or_404(BookMark, pk=id)
if request.user != mark.owner:
return HttpResponseBadRequest()
book_id = mark.book.id
try:
with transaction.atomic():
# update book rating
mark.book.update_rating(mark.rating, None)
mark.delete()
except IntegrityError as e:
return HttpResponseServerError()
return redirect(reverse("books:retrieve", args=[book_id]))
else:
return HttpResponseBadRequest()
@mastodon_request_included
@login_required
def create_review(request, book_id):
if request.method == 'GET':
form = BookReviewForm(initial={'book': book_id})
book = get_object_or_404(Book, pk=book_id)
return render(
request,
'books/create_update_review.html',
{
'form': form,
'title': _("添加评论"),
'book': book,
'submit_url': reverse("books:create_review", args=[book_id]),
}
)
elif request.method == 'POST':
form = BookReviewForm(request.POST)
if form.is_valid():
form.instance.owner = request.user
form.save()
if form.cleaned_data['share_to_mastodon']:
if form.cleaned_data['is_private']:
visibility = TootVisibilityEnum.PRIVATE
else:
visibility = TootVisibilityEnum.UNLISTED
url = "https://" + request.get_host() + reverse("books:retrieve_review",
args=[form.instance.id])
words = "发布了关于" + f"{form.instance.book.title}" + "的评论"
# tags = MASTODON_TAGS % {'category': '书', 'type': '评论'}
tags = ''
content = words + '\n' + url + \
'\n' + form.cleaned_data['title'] + '\n' + tags
response = post_toot(
request.user.mastodon_site, content, visibility, request.session['oauth_token'])
if response.status_code != 200:
mastodon_logger.error(
f"CODE:{response.status_code} {response.text}")
return HttpResponseServerError("publishing mastodon status failed")
return redirect(reverse("books:retrieve_review", args=[form.instance.id]))
else:
return HttpResponseBadRequest()
else:
return HttpResponseBadRequest()
@mastodon_request_included
@login_required
def update_review(request, id):
if request.method == 'GET':
review = get_object_or_404(BookReview, pk=id)
if request.user != review.owner:
return HttpResponseBadRequest()
form = BookReviewForm(instance=review)
book = review.book
return render(
request,
'books/create_update_review.html',
{
'form': form,
'title': _("编辑评论"),
'book': book,
'submit_url': reverse("books:update_review", args=[review.id]),
}
)
elif request.method == 'POST':
review = get_object_or_404(BookReview, pk=id)
if request.user != review.owner:
return HttpResponseBadRequest()
form = BookReviewForm(request.POST, instance=review)
if form.is_valid():
form.instance.edited_time = timezone.now()
form.save()
if form.cleaned_data['share_to_mastodon']:
if form.cleaned_data['is_private']:
visibility = TootVisibilityEnum.PRIVATE
else:
visibility = TootVisibilityEnum.UNLISTED
url = "https://" + request.get_host() + reverse("books:retrieve_review",
args=[form.instance.id])
words = "发布了关于" + f"{form.instance.book.title}" + "的评论"
# tags = MASTODON_TAGS % {'category': '书', 'type': '评论'}
tags = ''
content = words + '\n' + url + \
'\n' + form.cleaned_data['title'] + '\n' + tags
response = post_toot(
request.user.mastodon_site, content, visibility, request.session['oauth_token'])
if response.status_code != 200:
mastodon_logger.error(f"CODE:{response.status_code} {response.text}")
return HttpResponseServerError("publishing mastodon status failed")
return redirect(reverse("books:retrieve_review", args=[form.instance.id]))
else:
return HttpResponseBadRequest()
else:
return HttpResponseBadRequest()
@login_required
def delete_review(request, id):
if request.method == 'GET':
review = get_object_or_404(BookReview, pk=id)
if request.user != review.owner:
return HttpResponseBadRequest()
review_form = BookReviewForm(instance=review)
return render(
request,
'books/delete_review.html',
{
'form': review_form,
'review': review,
}
)
elif request.method == 'POST':
review = get_object_or_404(BookReview, pk=id)
if request.user != review.owner:
return HttpResponseBadRequest()
book_id = review.book.id
review.delete()
return redirect(reverse("books:retrieve", args=[book_id]))
else:
return HttpResponseBadRequest()
@mastodon_request_included
@login_required
def retrieve_review(request, id):
if request.method == 'GET':
review = get_object_or_404(BookReview, pk=id)
if not check_visibility(review, request.session['oauth_token'], request.user):
msg = _("你没有访问这个页面的权限😥")
return render(
request,
'common/error.html',
{
'msg': msg,
}
)
review_form = BookReviewForm(instance=review)
book = review.book
try:
mark = BookMark.objects.get(owner=review.owner, book=book)
mark.get_status_display = BookMarkStatusTranslator(mark.status)
except ObjectDoesNotExist:
mark = None
return render(
request,
'books/review_detail.html',
{
'form': review_form,
'review': review,
'book': book,
'mark': mark,
}
)
else:
return HttpResponseBadRequest()
@mastodon_request_included
@login_required
def retrieve_review_list(request, book_id):
if request.method == 'GET':
book = get_object_or_404(Book, pk=book_id)
queryset = BookReview.get_available(
book, request.user, request.session['oauth_token'])
paginator = Paginator(queryset, REVIEW_PER_PAGE)
page_number = request.GET.get('page', default=1)
reviews = paginator.get_page(page_number)
reviews.pagination = PageLinksGenerator(
PAGE_LINK_NUMBER, page_number, paginator.num_pages)
return render(
request,
'books/review_list.html',
{
'reviews': reviews,
'book': book,
}
)
else:
return HttpResponseBadRequest()
@login_required
def scrape(request):
if request.method == 'GET':
keywords = request.GET.get('q')
form = BookForm()
return render(
request,
'books/scrape.html',
{
'q': keywords,
'form': form,
}
)
else:
return HttpResponseBadRequest()
@login_required
def click_to_scrape(request):
if request.method == "POST":
url = request.POST.get("url")
if url:
from common.scraper import scrape_douban_book
try:
scraped_book, raw_cover = scrape_douban_book(url)
except TimeoutError:
return render(request, 'common/error.html', {'msg': _("爬取数据失败😫,请重试")})
except ValueError:
return render(request, 'common/error.html', {'msg': _("链接非法,爬取失败")})
scraped_cover = {
'cover': SimpleUploadedFile('temp.jpg', raw_cover)}
form = BookForm(scraped_book, scraped_cover)
if form.is_valid():
form.instance.last_editor = request.user
form.save()
return redirect(reverse('books:retrieve', args=[form.instance.id]))
else:
if 'isbn' in form.errors:
msg = _("ISBN与现有图书重复")
else:
msg = _("爬取数据失败😫")
logger.error(str(form.errors))
return render(request, 'common/error.html', {'msg': msg})
else:
return HttpResponseBadRequest()
else:
return HttpResponseBadRequest()