bugfix for Django 5: QuerySet in FilteredRelation
[wolnelektury.git] / src / catalogue / views.py
1 # This file is part of Wolne Lektury, licensed under GNU Affero GPLv3 or later.
2 # Copyright © Fundacja Wolne Lektury. See NOTICE for more information.
3 #
4 from collections import OrderedDict
5 import random
6 import re
7 from urllib.parse import quote_plus
8 from slugify import slugify
9 from zipstream import ZipStream
10
11 from django.conf import settings
12 from django.template.loader import render_to_string
13 from django.shortcuts import get_object_or_404, render, redirect
14 from django.http import HttpResponse, HttpResponseRedirect, Http404, HttpResponsePermanentRedirect, StreamingHttpResponse
15 from django.urls import reverse
16 from django.db.models import Q, QuerySet
17 from django.contrib.auth.decorators import login_required, user_passes_test
18 from django.utils import translation
19 from django.utils.translation import gettext_lazy
20 from django.views.decorators.cache import never_cache
21 from django.views.generic import TemplateView
22
23 from ajaxable.utils import AjaxableFormView
24 from club.forms import DonationStep1Form
25 from club.models import Club
26 from annoy.models import DynamicTextInsert
27 from pdcounter import views as pdcounter_views
28 from social.models import UserList
29 from wolnelektury.utils import is_ajax
30 from catalogue import constants
31 from catalogue import forms
32 from catalogue.helpers import get_top_level_related_tags
33 from catalogue.models import Book, Collection, Tag, Fragment
34 from catalogue.models.tag import TagRelation
35 from catalogue.utils import split_tags
36 from catalogue.models.tag import prefetch_relations
37
38 staff_required = user_passes_test(lambda user: user.is_staff)
39
40
41 def catalogue(request):
42     return render(request, 'catalogue/catalogue.html', {
43         'books': Book.objects.filter(findable=True, parent=None),
44         'collections': Collection.objects.filter(listed=True),
45     })
46
47
48 def daisy_list(request):
49     return object_list(request, Book.objects.filter(media__type='daisy'))
50
51
52 def collection(request, slug):
53     coll = get_object_or_404(Collection, slug=slug)
54     template_name = 'catalogue/collection.html'
55     return render(request, template_name, {
56         'collection': coll,
57     })
58
59
60 def differentiate_tags(request, tags, ambiguous_slugs):
61     beginning = '/'.join(tag.url_chunk for tag in tags)
62     unparsed = '/'.join(ambiguous_slugs[1:])
63     options = []
64     for tag in Tag.objects.filter(slug=ambiguous_slugs[0]):
65         options.append({
66             'url_args': '/'.join((beginning, tag.url_chunk, unparsed)).strip('/'),
67             'tags': [tag]
68         })
69     return render(
70         request,
71         'catalogue/differentiate_tags.html',
72         {'tags': tags, 'options': options, 'unparsed': ambiguous_slugs[1:]}
73     )
74
75
76 from django.db.models import Q
77 from django.views.decorators.cache import cache_control
78 from django.views.decorators.vary import vary_on_headers
79 from django.utils.decorators import method_decorator
80
81
82 @method_decorator([
83     vary_on_headers('X-Requested-With'),
84     cache_control(max_age=1),
85 ], 'dispatch')
86 class ObjectListView(TemplateView):
87     page_size = 100
88     themed_page_size = 10
89     item_template_name = ''
90     orderings = {}
91     default_ordering = None
92
93     def analyse(self):
94         self.is_themed = False
95         self.ctx = ctx = {}
96         ctx['tags'] = []        
97
98     def dispatch(self, *args, **kwargs):
99         try:
100             self.analyse()
101         except ResponseInstead as e:
102             return e.response
103         return super().dispatch(*args, **kwargs)
104         
105     def get_orderings(self):
106         order = self.get_order()
107         return [
108             {
109                 "slug": k,
110                 "name": v[1],
111                 "active": k == order,
112                 "default": v[0] is None,
113             }
114             for k, v in self.orderings.items()
115         ]
116
117     def get_order(self):
118         order = self.request.GET.get('order')
119         if order not in self.orderings:
120             order = self.default_ordering
121         return order
122
123     def order(self, qs):
124         order_tag = self.get_order()
125         if order_tag:
126             order = self.orderings[order_tag]
127             order_by = order[0]
128             if order_by:
129                 qs = qs.order_by(order_by)
130         return qs
131
132     def search(self, qs):
133         return qs
134
135     def get_template_names(self):
136         if is_ajax(self.request) or self.request.GET.get('dyn'):
137             if self.is_themed:
138                 return self.dynamic_themed_template_name
139             else:
140                 return self.dynamic_template_name
141         else:
142             if self.is_themed:
143                 return self.themed_template_name
144             else:
145                 return self.template_name
146
147     def get_context_data(self, **kwargs):
148         ctx = super().get_context_data()
149         ctx.update(self.ctx)
150         qs = self.get_queryset()
151         qs = self.search(qs)
152         qs = self.order(qs)
153
154         ctx['object_list'] = qs
155         ctx['suggested_tags'] = self.get_suggested_tags(qs)
156         ctx['suggested_tags_by_category'] = split_tags(ctx['suggested_tags'])
157         return ctx
158
159
160 class BookList(ObjectListView):
161     title = gettext_lazy('Literatura')
162     list_type = 'books'
163     template_name = 'catalogue/book_list.html'
164     dynamic_template_name = 'catalogue/dynamic_book_list.html'
165     themed_template_name = 'catalogue/themed_book_list.html'
166     dynamic_themed_template_name = 'catalogue/dynamic_themed_book_list.html'
167
168     orderings = {
169         'pop': ('-popularity__count', gettext_lazy('najpopularniejsze')),
170         'alpha': (None, gettext_lazy('alfabetycznie')),
171     }
172     default_ordering = 'alpha'
173
174     def get_queryset(self):
175         return Book.objects.filter(parent=None, findable=True)
176
177     def search(self, qs):
178         term = self.request.GET.get('search')
179         if term:
180             meta_rels = TagRelation.objects.filter(tag__category='author')
181             # TODO: search tags in currently displaying language
182             if self.is_themed:
183                 rels = meta_rels.filter(tag__name_pl__icontains=term)
184                 qs = qs.filter(
185                     Q(book__title__icontains=term) |
186                     Q(tag_relations__in=rels) |
187                     Q(text__icontains=term)
188                 ).distinct()
189             else:
190                 rels = meta_rels.filter(tag__name_pl__icontains=term)
191                 qs = qs.filter(Q(title__icontains=term) | Q(tag_relations__in=rels)).distinct()
192         return qs
193
194
195 class LiteratureView(BookList):
196     def get_suggested_tags(self, queryset):
197         tags = list(get_top_level_related_tags([]))
198         tags.sort(key=lambda t: -t.count)
199         if self.request.user.is_authenticated:
200             tags.extend(list(Tag.objects.filter(user=self.request.user).exclude(name='')))
201         return tags
202
203
204 class AudiobooksView(LiteratureView):
205     title = gettext_lazy('Audiobooki')
206     list_type = 'audiobooks'
207
208     def get_queryset(self):
209         return Book.objects.filter(findable=True, media__type='mp3').distinct()
210
211
212 class TaggedObjectList(BookList):
213     def analyse(self):
214         super().analyse()
215
216         self.ctx['tags'] = analyse_tags(self.request, self.kwargs['tags'])
217         if len(self.ctx['tags']) > 4:
218             raise Http404
219         self.ctx.update({
220             'fragment_tags': [],
221             'work_tags': [],
222             'user_lists': [],
223         })
224         for tag in self.ctx['tags']:
225             if isinstance(tag, UserList):
226                 self.ctx['user_lists'].append(tag)
227             elif tag.category == 'theme':
228                 self.ctx['fragment_tags'].append(tag)
229             else:
230                 self.ctx['work_tags'].append(tag)
231
232         self.is_themed = self.ctx['has_theme'] = bool(self.ctx['fragment_tags'])
233         if self.is_themed:
234             self.ctx['main_tag'] = self.ctx['fragment_tags'][0]
235         elif self.ctx['work_tags']:
236             self.ctx['main_tag'] = self.ctx['work_tags'][0]
237         else:
238             self.ctx['main_tag'] = None
239         self.ctx['filtering_tags'] = [
240             t for t in self.ctx['tags']
241             if t is not self.ctx['main_tag']
242         ]
243         if len(self.ctx['tags']) == 1 and self.ctx['main_tag'] is not None and self.ctx['main_tag'].category == 'author':
244             self.ctx['translation_list'] = self.ctx['main_tag'].book_set.all()
245             self.ctx['narrated'] = self.ctx['main_tag'].narrated.all()
246
247     def get_queryset(self):
248         if self.ctx['work_tags']:
249             qs = Book.tagged.with_all(self.ctx['work_tags']).filter(findable=True)
250         else:
251             qs = Book.objects.filter(findable=True)
252         for ul in self.ctx['user_lists']:
253             qs = qs.filter(id__in=[i.id for i in ul.get_books()])
254         qs = qs.exclude(ancestor__in=qs)
255         if self.is_themed:
256             fqs = Fragment.tagged.with_all(self.ctx['fragment_tags'])
257             if self.ctx['work_tags']:
258                 fqs = fqs.filter(
259                     Q(book__in=qs) | Q(book__ancestor__in=qs)
260                 )
261             qs = fqs
262         return qs
263
264     def get_suggested_tags(self, queryset):
265         if self.ctx['user_lists']:
266             # TODO
267             return []
268         tag_ids = [t.id for t in self.ctx['tags']]
269         if self.is_themed:
270             related_tags = []
271             current_books = self.get_queryset().values_list('book', flat=True).distinct()
272             containing_books = Book.objects.filter(Q(id__in=current_books) | Q(children__in=current_books))
273
274             related_tags.extend(list(
275                 Tag.objects.usage_for_queryset(
276                     containing_books,
277                 ).exclude(category='set').exclude(pk__in=tag_ids)
278             ))
279             ### FIXME: These won't be tags
280             if self.request.user.is_authenticated:
281                 related_tags.extend(list(
282                     Tag.objects.usage_for_queryset(
283                         containing_books
284                     ).filter(
285                         user=self.request.user
286                     ).exclude(name='').exclude(pk__in=tag_ids)
287                 ))
288         else:
289             related_tags = list(get_top_level_related_tags(self.ctx['tags']))
290             if self.request.user.is_authenticated:
291                 qs = Book.tagged.with_all(self.ctx['tags']).filter(findable=True)
292                 related_tags.extend(list(
293                     Tag.objects.usage_for_queryset(
294                         qs
295                     ).filter(
296                         user=self.request.user
297                     ).exclude(name='').exclude(pk__in=tag_ids)
298                 ))
299
300             fragments = Fragment.objects.filter(
301                 Q(book__in=queryset) | Q(book__ancestor__in=queryset)
302             )
303             related_tags.extend(
304                 Tag.objects.usage_for_queryset(
305                     fragments, counts=True
306                 ).filter(category__in=('theme', 'object')).exclude(pk__in=tag_ids)
307             .only('name', 'sort_key', 'category', 'slug'))
308
309         return related_tags
310
311     
312     
313 def object_list(request, objects, list_type='books'):
314     related_tag_lists = []
315     if True:
316         related_tag_lists.append(
317             Tag.objects.usage_for_queryset(
318                 objects, counts=True
319             ).exclude(category='set'))
320         ### FIXME: these won't be tags
321         if request.user.is_authenticated:
322             related_tag_lists.append(
323                 Tag.objects.usage_for_queryset(
324                     objects, counts=True
325                 ).filter(
326                     user=request.user
327                 ).exclude(name='')
328             )
329     if True:
330         fragments = Fragment.objects.filter(book__in=objects)
331         related_tag_lists.append(
332             Tag.objects.usage_for_queryset(
333                 fragments, counts=True
334             ).filter(category='theme')
335             .only('name', 'sort_key', 'category', 'slug'))
336         if isinstance(objects, QuerySet):
337             objects = prefetch_relations(objects, 'author')
338
339     categories = split_tags(*related_tag_lists)
340     suggest = []
341     for c in ['set', 'author', 'epoch', 'kind', 'genre']:
342         suggest.extend(sorted(categories[c], key=lambda t: -t.count))
343
344     objects = list(objects)
345
346     result = {
347         'object_list': objects,
348         'suggest': suggest,
349         'list_type': list_type,
350     }
351
352     template = 'catalogue/author_detail.html'
353
354     return render(
355         request, template, result,
356     )
357
358
359 class ResponseInstead(Exception):
360     def __init__(self, response):
361         super(ResponseInstead, self).__init__()
362         self.response = response
363
364
365 def analyse_tags(request, tag_str):
366     try:
367         tags = Tag.get_tag_list(tag_str)
368     except Tag.DoesNotExist:
369         # Perhaps the user is asking about an author in Public Domain
370         # counter (they are not represented in tags)
371         chunks = tag_str.split('/')
372         if len(chunks) == 2 and chunks[0] == 'autor':
373             raise ResponseInstead(pdcounter_views.author_detail(request, chunks[1]))
374         raise Http404
375     except Tag.MultipleObjectsReturned as e:
376         # Ask the user to disambiguate
377         raise ResponseInstead(differentiate_tags(request, e.tags, e.ambiguous_slugs))
378     except Tag.UrlDeprecationWarning as e:
379         raise ResponseInstead(HttpResponsePermanentRedirect(
380             reverse('tagged_object_list', args=['/'.join(tag.url_chunk for tag in e.tags)])))
381
382     if not tags:
383         raise Http404
384     try:
385         if len(tags) > settings.MAX_TAG_LIST:
386             raise Http404
387     except AttributeError:
388         pass
389
390     return tags
391
392
393 def tagged_object_list(request, tags, list_type):
394     return TaggedObjectList.as_view()(request, tags=tags)
395
396
397 def book_fragments(request, slug, theme_slug):
398     book = get_object_or_404(Book, slug=slug)
399     theme = get_object_or_404(Tag, slug=theme_slug, category='theme')
400     fragments = Fragment.tagged.with_all([theme]).filter(
401         Q(book=book) | Q(book__ancestor=book))
402
403     template_name = 'catalogue/book_fragments.html'
404     return render(
405         request,
406         template_name,
407         {
408             'book': book,
409             'theme': theme,
410             'fragments': fragments,
411         })
412
413
414 @never_cache
415 def book_detail(request, slug):
416     try:
417         book = Book.objects.get(slug=slug)
418     except Book.DoesNotExist:
419         return pdcounter_views.book_stub_detail(request, slug)
420
421     return render(
422         request,
423         'catalogue/book_detail.html',
424         {
425             'book': book,
426             'accessible': book.is_accessible_to(request.user),
427             'book_children': book.children.all().order_by('parent_number', 'sort_key'),
428             'club': Club.objects.first() if book.preview else None,
429             'donation_form': DonationStep1Form(),
430         })
431
432
433 def book_text(request, slug):
434     book = get_object_or_404(Book, slug=slug)
435
436     if not book.is_accessible_to(request.user):
437         return HttpResponseRedirect(book.get_absolute_url())
438
439     if not book.has_html_file():
440         raise Http404
441     with book.html_file.open('r') as f:
442         book_text = f.read()
443
444     return render(request, 'catalogue/book_text.html', {
445         'book': book,
446         'extra_info': book.get_extra_info_json(),
447         'book_text': book_text,
448         'inserts': DynamicTextInsert.get_all(request),
449
450         'club': Club.objects.first(),
451         'donation_form': DonationStep1Form(),
452     })
453
454
455 # =========
456 # = Admin =
457 # =========
458 @login_required
459 @staff_required
460 def import_book(request):
461     """docstring for import_book"""
462     book_import_form = forms.BookImportForm(request.POST, request.FILES)
463     if book_import_form.is_valid():
464         try:
465             book_import_form.save()
466         except:
467             import sys
468             import pprint
469             import traceback
470             info = sys.exc_info()
471             exception = pprint.pformat(info[1])
472             tb = '\n'.join(traceback.format_tb(info[2]))
473             return HttpResponse(
474                 "Błąd: %(exception)s\n\n%(tb)s" % {
475                     'exception': exception, 'tb': tb
476                 },
477                 content_type='text/plain'
478             )
479         return HttpResponse("Książka zaimportowana")
480     return HttpResponse("Błąd podczas importowania pliku: %r" % book_import_form.errors)
481
482
483 # info views for API
484
485 def book_info(request, book_id, lang='pl'):
486     book = get_object_or_404(Book, id=book_id)
487     # set language by hand
488     translation.activate(lang)
489     return render(request, 'catalogue/book_info.html', {'book': book})
490
491
492 def tag_info(request, tag_id):
493     tag = get_object_or_404(Tag, id=tag_id)
494     return HttpResponse(tag.description)
495
496
497 @never_cache
498 def embargo_link(request, key, format_, slug):
499     book = get_object_or_404(Book, slug=slug)
500     if format_ not in Book.formats:
501         raise Http404
502     if key != book.preview_key:
503         raise Http404
504     media_file = book.get_media(format_)
505     if not book.preview:
506         return HttpResponseRedirect(media_file.url)
507     return HttpResponse(media_file, content_type=constants.EBOOK_CONTENT_TYPES[format_])
508
509
510 def download_zip(request, file_format=None, media_format=None, slug=None):
511     if file_format:
512         url = Book.zip_format(file_format)
513     elif media_format and slug is not None:
514         book = get_object_or_404(Book, slug=slug)
515         url = book.zip_audiobooks(media_format)
516     else:
517         raise Http404('No format specified for zip package')
518     return HttpResponseRedirect(quote_plus(settings.MEDIA_URL + url, safe='/?='))
519
520
521 def stream_zip(request, media_format=None, slug=None):
522     book = get_object_or_404(Book, slug=slug)
523     def iterate_audiobooks(book, names):
524         for bm in book.media.filter(type=media_format).order_by('index'):
525             yield (
526                 bm.file.path,
527                 bm.get_extra_info_json().get('license'),
528                 names + (slugify(bm.part_name),) if bm.part_name else names
529             )
530         for child in book.get_children():
531             yield from iterate_audiobooks(child, names + (slugify(child.title),))
532
533     zs = ZipStream()
534
535     audiobook_list = list(iterate_audiobooks(book, ()))
536     
537     licenses = set()
538     for i, (file_path, lic, names) in enumerate(audiobook_list):
539         index = i + 1
540         part_name = '_'.join(names)
541         if part_name:
542             part_name = '_' + part_name
543         ext = file_path.rsplit('.', 1)[-1]
544         if len(audiobook_list) > 1:
545             zip_name = f'{book.slug}_{index:03d}{part_name}'[:240] + '.' + ext
546         else:
547             zip_name = book.slug[:240] + '.' + ext
548         zs.add_path(file_path, zip_name)
549
550         lic_name = constants.LICENSES.get(lic, {}).get('locative')
551         if lic_name:
552             licenses.add(lic_name)
553
554     readme = render_to_string('catalogue/audiobook_zip_readme.txt', {
555         'licenses': licenses,
556     })
557     zs.add(readme, 'informacje.txt')
558
559     response = StreamingHttpResponse(zs, content_type='application/zip')
560     response['Content-Disposition'] = f'attachment; filename={slug}_{media_format}.zip'
561     return response
562
563
564 class CustomPDFFormView(AjaxableFormView):
565     form_class = forms.CustomPDFForm
566     title = gettext_lazy('Stwórz własny PDF')
567     submit = gettext_lazy('Pobierz')
568     template = 'catalogue/custom_pdf_form.html'
569     honeypot = True
570
571     def __call__(self, *args, **kwargs):
572         if settings.NO_CUSTOM_PDF:
573             raise Http404('Custom PDF is disabled')
574         return super(CustomPDFFormView, self).__call__(*args, **kwargs)
575
576     def form_args(self, request, obj):
577         """Override to parse view args and give additional args to the form."""
578         return (obj,), {}
579
580     def validate_object(self, obj, request):
581         book = obj
582         if not book.is_accessible_to(request.user):
583             return HttpResponseRedirect(book.get_absolute_url())
584         return super(CustomPDFFormView, self).validate_object(obj, request)
585
586     def get_object(self, request, slug, *args, **kwargs):
587         book = get_object_or_404(Book, slug=slug)
588         return book
589
590     def context_description(self, request, obj):
591         return obj.pretty_title()
592
593
594 def tag_catalogue(request, category):
595     if category == 'theme':
596         tags = Tag.objects.usage_for_model(
597             Fragment, counts=True).filter(category='theme')
598     else:
599         tags = list(get_top_level_related_tags((), categories=(category,)))
600
601     described_tags = [tag for tag in tags if tag.description]
602
603     if len(described_tags) > 4:
604         best = random.sample(described_tags, 4)
605     else:
606         best = described_tags
607
608     template_name = 'catalogue/tag_catalogue.html'
609     return render(request, template_name, {
610         'tags': tags,
611         'best': best,
612         'title': constants.CATEGORIES_NAME_PLURAL[category],
613         'whole_category': constants.WHOLE_CATEGORY[category],
614     })
615
616
617 def collections(request):
618     objects = Collection.objects.filter(listed=True)
619
620     if len(objects) > 3:
621         best = random.sample(list(objects), 4)
622     else:
623         best = objects
624
625     template_name = 'catalogue/collections.html'
626     return render(request, template_name, {
627         'objects': objects,
628         'best': best,
629     })
630
631
632 def ridero_cover(request, slug):
633     from librarian.cover import make_cover
634     wldoc = Book.objects.get(slug=slug).wldocument()
635     cover = make_cover(wldoc.book_info, width=980, bleed=20, format='PNG')
636     response = HttpResponse(content_type="image/png")
637     cover.save(response)
638     return response
639
640
641 def get_isbn(request, book_format, slug):
642     book = Book.objects.get(slug=slug)
643     return HttpResponse(book.get_extra_info_json().get('isbn_%s' % book_format))