+ 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('Literatura')
+ list_type = 'books'
+ template_name = 'catalogue/book_list.html'
+ dynamic_template_name = 'catalogue/dynamic_book_list.html'
+ themed_template_name = 'catalogue/themed_book_list.html'
+ dynamic_themed_template_name = 'catalogue/dynamic_themed_book_list.html'
+
+ orderings = {
+ 'pop': ('-popularity__count', gettext_lazy('najpopularniejsze')),
+ 'alpha': (None, gettext_lazy('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.filter(tag__category='author')
+ # TODO: search tags in currently displaying language
+ if self.is_themed:
+ rels = meta_rels.filter(tag__name_pl__icontains=term)
+ qs = qs.filter(
+ Q(book__title__icontains=term) |
+ Q(tag_relations__in=rels) |
+ 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 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('Audiobooki')
+ list_type = 'audiobooks'
+
+ def get_queryset(self):
+ return Book.objects.filter(findable=True, media__type='mp3').distinct()
+
+
+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'])
+ if self.is_themed:
+ self.ctx['main_tag'] = self.ctx['fragment_tags'][0]
+ elif self.ctx['tags']:
+ self.ctx['main_tag'] = self.ctx['tags'][0]
+ else:
+ self.ctx['main_tag'] = None
+ self.ctx['filtering_tags'] = [
+ t for t in self.ctx['tags']
+ if t is not self.ctx['main_tag']
+ ]
+ if len(self.ctx['tags']) == 1 and self.ctx['main_tag'].category == 'author':
+ self.ctx['translation_list'] = self.ctx['main_tag'].book_set.all()
+
+ 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:
+ fqs = Fragment.tagged.with_all(self.ctx['fragment_tags'])
+ if self.ctx['work_tags']:
+ fqs = fqs.filter(
+ Q(book__in=qs) | Q(book__ancestor__in=qs)
+ )
+ qs = fqs
+ return qs
+
+ def get_suggested_tags(self, queryset):
+ tag_ids = [t.id for t in self.ctx['tags']]
+ if self.is_themed:
+ related_tags = []
+ current_books = self.get_queryset().values_list('book', flat=True).distinct()
+ containing_books = Book.objects.filter(Q(id__in=current_books) | Q(children__in=current_books))
+
+ related_tags.extend(list(
+ Tag.objects.usage_for_queryset(
+ containing_books,
+ ).exclude(category='set').exclude(pk__in=tag_ids)
+ ))
+ if self.request.user.is_authenticated:
+ related_tags.extend(list(
+ Tag.objects.usage_for_queryset(
+ containing_books
+ ).filter(
+ user=self.request.user
+ ).exclude(name='').exclude(pk__in=tag_ids)
+ ))
+ else:
+ related_tags = list(get_top_level_related_tags(self.ctx['tags']))
+ 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, list_type='books'):
fnp / wolnelektury.git / blobdiff