from django.utils import translation
from django.utils.translation import gettext as _, gettext_lazy
from django.views.decorators.cache import never_cache
+from django.views.generic import TemplateView
from ajaxable.utils import AjaxableFormView
from club.forms import ScheduleForm, DonationStep1Form
from annoy.models import DynamicTextInsert
from pdcounter import views as pdcounter_views
from picture.models import Picture, PictureArea
+from wolnelektury.utils import is_ajax
from catalogue import constants
from catalogue import forms
from catalogue.helpers import get_top_level_related_tags
from catalogue.models import Book, Collection, Tag, Fragment
+from catalogue.models.tag import TagRelation
from catalogue.utils import split_tags
from catalogue.models.tag import prefetch_relations
)
+from django.db.models import FilteredRelation, Q
+from django.views.decorators.cache import cache_control
+from django.views.decorators.vary import vary_on_headers
+from django.utils.decorators import method_decorator
+
+
+@method_decorator([
+ vary_on_headers('X-Requested-With'),
+ cache_control(max_age=1),
+], 'dispatch')
+class ObjectListView(TemplateView):
+ page_size = 100
+ themed_page_size = 10
+ item_template_name = ''
+ orderings = {}
+ default_ordering = None
+
+ def analyse(self):
+ self.is_themed = False
+ self.ctx = ctx = {}
+ ctx['tags'] = []
+
+ def dispatch(self, *args, **kwargs):
+ try:
+ self.analyse()
+ except ResponseInstead as e:
+ return e.response
+ return super().dispatch(*args, **kwargs)
+
+ def get_orderings(self):
+ order = self.get_order()
+ return [
+ {
+ "slug": k,
+ "name": v[1],
+ "active": k == order,
+ "default": v[0] is None,
+ }
+ for k, v in self.orderings.items()
+ ]
+
+ def get_order(self):
+ order = self.request.GET.get('order')
+ if order not in self.orderings:
+ order = self.default_ordering
+ return order
+
+ def order(self, qs):
+ order_tag = self.get_order()
+ if order_tag:
+ order = self.orderings[order_tag]
+ order_by = order[0]
+ if order_by:
+ qs = qs.order_by(order_by)
+ return qs
+
+ def search(self, qs):
+ return qs
+
+ def get_template_names(self):
+ if is_ajax(self.request) or self.request.GET.get('dyn'):
+ if self.is_themed:
+ return self.dynamic_themed_template_name
+ else:
+ return self.dynamic_template_name
+ else:
+ if self.is_themed:
+ return self.themed_template_name
+ else:
+ return self.template_name
+
+ def get_context_data(self, **kwargs):
+ ctx = super().get_context_data()
+ ctx.update(self.ctx)
+ qs = self.get_queryset()
+ qs = self.search(qs)
+ qs = self.order(qs)
+
+ ctx['object_list'] = qs
+ ctx['suggested_tags'] = self.get_suggested_tags(qs)
+ ctx['suggested_tags_by_category'] = split_tags(ctx['suggested_tags'])
+ return ctx
+
+
+class BookList(ObjectListView):
+ title = gettext_lazy('Literature')
+ list_type = 'books'
+ template_name = 'catalogue/2022/book_list.html'
+ dynamic_template_name = 'catalogue/2022/dynamic_book_list.html'
+ themed_template_name = 'catalogue/2022/themed_book_list.html'
+ dynamic_themed_template_name = 'catalogue/2022/dynamic_themed_book_list.html'
+
+ orderings = {
+ 'pop': ('-popularity__count', 'najpopularniejsze'),
+ 'alpha': (None, 'alfabetycznie'),
+ }
+ default_ordering = 'alpha'
+
+ def get_queryset(self):
+ return Book.objects.filter(parent=None, findable=True)
+
+ def search(self, qs):
+ term = self.request.GET.get('search')
+ if term:
+ meta_rels = TagRelation.objects.exclude(tag__category='set')
+ # TODO: search tags in currently displaying language
+ if self.is_themed:
+ #qs = qs.annotate(
+ # meta=FilteredRelation('book__tag_relations', condition=Q(tag_relations__in=meta_rels))
+ #)
+ qs = qs.filter(
+ Q(book__title__icontains=term) |
+ #Q(meta__tag_relations__tag__name_pl__icontains=term) |
+ Q(text__icontains=term)
+ ).distinct()
+ else:
+ qs = qs.annotate(
+ meta=FilteredRelation('tag_relations', condition=Q(tag_relations__in=meta_rels))
+ )
+ qs = qs.filter(Q(title__icontains=term) | Q(meta__tag__name_pl__icontains=term)).distinct()
+ return qs
+
+
+class ArtList(ObjectListView):
+ template_name = 'catalogue/2022/book_list.html'
+ dynamic_template_name = 'catalogue/2022/dynamic_book_list.html'
+ title = gettext_lazy('Art')
+ list_type = 'gallery'
+
+ def get_queryset(self):
+ return Picture.objects.all()
+
+ def search(self, qs):
+ term = self.request.GET.get('search')
+ if term:
+ qs = qs.filter(Q(title__icontains=term) | Q(tag_relations__tag__name_pl__icontains=term)).distinct()
+ return qs
+
+
+class LiteratureView(BookList):
+ def get_suggested_tags(self, queryset):
+ tags = list(get_top_level_related_tags([]))
+ tags.sort(key=lambda t: -t.count)
+ if self.request.user.is_authenticated:
+ tags.extend(list(Tag.objects.filter(user=self.request.user).exclude(name='')))
+ return tags
+
+
+class AudiobooksView(LiteratureView):
+ title = gettext_lazy('Audiobooks')
+ list_type = 'audiobooks'
+
+ def get_queryset(self):
+ return Book.objects.filter(findable=True, media__type='mp3').distinct()
+
+
+class GalleryView(ArtList):
+ def get_suggested_tags(self, queryset):
+ return Tag.objects.usage_for_queryset(
+ queryset,
+ counts=True
+ ).exclude(pk__in=[t.id for t in self.ctx['tags']]).order_by('-count')
+
+
+class TaggedObjectList(BookList):
+ def analyse(self):
+ super().analyse()
+ self.ctx['tags'] = analyse_tags(self.request, self.kwargs['tags'])
+ self.ctx['fragment_tags'] = [t for t in self.ctx['tags'] if t.category in ('theme', 'object')]
+ self.ctx['work_tags'] = [t for t in self.ctx['tags'] if t not in self.ctx['fragment_tags']]
+ self.is_themed = self.ctx['has_theme'] = bool(self.ctx['fragment_tags'])
+ self.ctx['main_tag'] = self.ctx['fragment_tags'][0] if self.is_themed else self.ctx['tags'][0]
+ self.ctx['filtering_tags'] = [
+ t for t in self.ctx['tags']
+ if t is not self.ctx['main_tag']
+ ]
+
+ def get_queryset(self):
+ qs = Book.tagged.with_all(self.ctx['work_tags']).filter(findable=True)
+ qs = qs.exclude(ancestor__in=qs)
+ if self.is_themed:
+ qs = Fragment.tagged.with_all(self.ctx['fragment_tags']).filter(
+ Q(book__in=qs) | Q(book__ancestor__in=qs)
+ )
+ return qs
+
+ def get_suggested_tags(self, queryset):
+ tag_ids = [t.id for t in self.ctx['tags']]
+ related_tags = list(get_top_level_related_tags(self.ctx['tags']))
+ if not self.is_themed:
+ if self.request.user.is_authenticated:
+ qs = Book.tagged.with_all(self.ctx['tags']).filter(findable=True)
+ related_tags.extend(list(
+ Tag.objects.usage_for_queryset(
+ qs
+ ).filter(
+ user=self.request.user
+ ).exclude(name='').exclude(pk__in=tag_ids)
+ ))
+
+ fragments = Fragment.objects.filter(
+ Q(book__in=queryset) | Q(book__ancestor__in=queryset)
+ )
+ related_tags.extend(
+ Tag.objects.usage_for_queryset(
+ fragments, counts=True
+ ).filter(category__in=('theme', 'object')).exclude(pk__in=tag_ids)
+ .only('name', 'sort_key', 'category', 'slug'))
+
+ return related_tags
+
+
+
def object_list(request, objects, fragments=None, related_tags=None, tags=None,
list_type='books', extra=None):
if not tags:
Tag.objects.usage_for_queryset(
objects, counts=True
).exclude(category='set').exclude(pk__in=tag_ids))
+ if request.user.is_authenticated:
+ related_tag_lists.append(
+ Tag.objects.usage_for_queryset(
+ objects, counts=True
+ ).filter(
+ user=request.user
+ ).exclude(name='').exclude(pk__in=tag_ids)
+ )
if not (extra and extra.get('theme_is_set')):
if fragments is None:
if list_type == 'gallery':
categories = split_tags(*related_tag_lists)
suggest = []
- for c in ['author', 'epoch', 'kind', 'genre']:
- #if len(categories.get(c, [])) > 1:
- suggest.extend(sorted(categories[c], key=lambda t: -t.count)[:3])
+ for c in ['set', 'author', 'epoch', 'kind', 'genre']:
+ suggest.extend(sorted(categories[c], key=lambda t: -t.count))
objects = list(objects)
'suggest': suggest,
'list_type': list_type,
'tags': tags,
+ 'main_tag': tags[0] if tags else None,
'formats_form': forms.DownloadFormatsForm(),
'best': best,
if extra:
result.update(extra)
- is_set = any((x.category == 'set' for x in tags))
- is_theme = len(tags) == 1 and tags[0].category == 'theme'
- has_theme = any((x.category == 'theme' for x in tags))
- new_layout = request.EXPERIMENTS['layout']
-
- if is_set and new_layout.value:
- template = 'social/2022/set_detail.html'
- elif is_theme and new_layout.value:
- template = 'catalogue/2022/theme_detail.html'
- elif new_layout.value and not has_theme:
- template = 'catalogue/2022/author_detail.html'
+ if request.EXPERIMENTS['layout'].value:
+ has_theme = any(((theme := x).category == 'theme' for x in tags))
+ if has_theme:
+ result['main_tag'] = theme
+ template = 'catalogue/2022/theme_detail.html'
+ else:
+ template = 'catalogue/2022/author_detail.html'
else:
template = 'catalogue/tagged_object_list.html'
def literature(request):
+ if request.EXPERIMENTS['layout'].value:
+ return LiteratureView.as_view()(request)
books = Book.objects.filter(parent=None, findable=True)
return object_list(request, books, related_tags=get_top_level_related_tags([]))
def gallery(request):
+ if request.EXPERIMENTS['layout'].value:
+ return GalleryView.as_view()(request)
return object_list(request, Picture.objects.all(), list_type='gallery')
def audiobooks(request):
+ if request.EXPERIMENTS['layout'].value:
+ return AudiobooksView.as_view()(request)
audiobooks = Book.objects.filter(findable=True, media__type__in=('mp3', 'ogg')).distinct()
return object_list(request, audiobooks, list_type='audiobooks', extra={
'daisy': Book.objects.filter(findable=True, media__type='daisy').distinct(),
def tagged_object_list(request, tags, list_type):
+ if request.EXPERIMENTS['layout'].value and list_type in ('books', 'audiobooks'):
+ return TaggedObjectList.as_view()(request, tags=tags)
+
try:
tags = analyse_tags(request, tags)
except ResponseInstead as e:
fragments = Fragment.tagged.with_all([theme]).filter(
Q(book=book) | Q(book__ancestor=book))
+ if request.EXPERIMENTS['layout'].value:
+ template_name = 'catalogue/2022/book_fragments.html'
+ else:
+ template_name = 'catalogue/book_fragments.html'
+
return render(
request,
- 'catalogue/book_fragments.html',
+ template_name,
{
'book': book,
'theme': theme,
fnp / wolnelektury.git / blobdiff