X-Git-Url: https://git.mdrn.pl/wolnelektury.git/blobdiff_plain/28de2870cc094e3b5cbcf7eea54d3a4b7736e450..480da6ff4ed8c04b205710c318b2fcfcb961bbc7:/apps/opds/views.py diff --git a/apps/opds/views.py b/apps/opds/views.py index 7ee09be7c..8fe0b8f1b 100644 --- a/apps/opds/views.py +++ b/apps/opds/views.py @@ -2,8 +2,8 @@ # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later. # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information. # -from base64 import b64encode import os.path +from urlparse import urljoin from django.contrib.syndication.views import Feed from django.core.urlresolvers import reverse @@ -15,8 +15,16 @@ from django.contrib.sites.models import Site from basicauth import logged_in_or_basicauth, factory_decorator from catalogue.models import Book, Tag -from catalogue.views import books_starting_with +from search.views import get_search, SearchResult, JVM +from lucene import Term, QueryWrapperFilter, TermQuery + +import logging +import re + +log = logging.getLogger('opds') + +from stats.utils import piwik_track _root_feeds = ( { @@ -58,7 +66,7 @@ _root_feeds = ( def full_url(url): - return "http://%s%s" % (Site.objects.get_current().domain, url) + return urljoin("http://%s" % Site.objects.get_current().domain, url) class OPDSFeed(Atom1Feed): @@ -180,19 +188,19 @@ class AcquisitionFeed(Feed): return u'' def item_enclosure_url(self, book): - return full_url(book.root_ancestor.epub_file.url) + return full_url(book.epub_file.url) if book.epub_file else None def item_enclosure_length(self, book): - return book.root_ancestor.epub_file.size - + return book.epub_file.size if book.epub_file else None +@piwik_track class RootFeed(Feed): feed_type = OPDSFeed title = u'Wolne Lektury' - link = u'http://www.wolnelektury.pl/' + link = u'http://wolnelektury.pl/' description = u"Spis utworów na stronie http://WolneLektury.pl" author_name = u"Wolne Lektury" - author_link = u"http://www.wolnelektury.pl/" + author_link = u"http://wolnelektury.pl/" def items(self): return _root_feeds @@ -206,13 +214,13 @@ class RootFeed(Feed): def item_description(self, item): return item['description'] - +@piwik_track class ByCategoryFeed(Feed): feed_type = OPDSFeed - link = u'http://www.wolnelektury.pl/' + link = u'http://wolnelektury.pl/' description = u"Spis utworów na stronie http://WolneLektury.pl" author_name = u"Wolne Lektury" - author_link = u"http://www.wolnelektury.pl/" + author_link = u"http://wolnelektury.pl/" def get_object(self, request, category): feed = [feed for feed in _root_feeds if feed['category']==category] @@ -227,7 +235,7 @@ class ByCategoryFeed(Feed): return feed['title'] def items(self, feed): - return (tag for tag in Tag.objects.filter(category=feed['category']) if tag.get_count() > 0) + return Tag.objects.filter(category=feed['category']).exclude(book_count=0) def item_title(self, item): return item.name @@ -238,7 +246,7 @@ class ByCategoryFeed(Feed): def item_description(self): return u'' - +@piwik_track class ByTagFeed(AcquisitionFeed): def link(self, tag): return tag.get_absolute_url() @@ -254,7 +262,7 @@ class ByTagFeed(AcquisitionFeed): def items(self, tag): books = Book.tagged.with_any([tag]) - l_tags = Tag.objects.filter(category='book', slug__in=[book.book_tag_slug() for book in books]) + l_tags = Tag.objects.filter(category='book', slug__in=[book.book_tag_slug() for book in books.iterator()]) descendants_keys = [book.pk for book in Book.tagged.with_any(l_tags)] if descendants_keys: books = books.exclude(pk__in=descendants_keys) @@ -262,13 +270,14 @@ class ByTagFeed(AcquisitionFeed): return books -#@factory_decorator(logged_in_or_basicauth()) +@factory_decorator(logged_in_or_basicauth()) +@piwik_track class UserFeed(Feed): feed_type = OPDSFeed link = u'http://www.wolnelektury.pl/' description = u"Półki użytkownika na stronie http://WolneLektury.pl" author_name = u"Wolne Lektury" - author_link = u"http://www.wolnelektury.pl/" + author_link = u"http://wolnelektury.pl/" def get_object(self, request): return request.user @@ -277,7 +286,7 @@ class UserFeed(Feed): return u"Półki użytkownika %s" % user.username def items(self, user): - return (tag for tag in Tag.objects.filter(category='set', user=user) if tag.get_count() > 0) + return Tag.objects.filter(category='set', user=user).exclude(book_count=0) def item_title(self, item): return item.name @@ -289,10 +298,11 @@ class UserFeed(Feed): return u'' # no class decorators in python 2.5 -UserFeed = factory_decorator(logged_in_or_basicauth())(UserFeed) +#UserFeed = factory_decorator(logged_in_or_basicauth())(UserFeed) -#@factory_decorator(logged_in_or_basicauth()) +@factory_decorator(logged_in_or_basicauth()) +@piwik_track class UserSetFeed(AcquisitionFeed): def link(self, tag): return tag.get_absolute_url() @@ -310,22 +320,137 @@ class UserSetFeed(AcquisitionFeed): return Book.tagged.with_any([tag]) # no class decorators in python 2.5 -UserSetFeed = factory_decorator(logged_in_or_basicauth())(UserSetFeed) +#UserSetFeed = factory_decorator(logged_in_or_basicauth())(UserSetFeed) +@piwik_track class SearchFeed(AcquisitionFeed): description = u"Wyniki wyszukiwania na stronie WolneLektury.pl" title = u"Wyniki wyszukiwania" + + INLINE_QUERY_RE = re.compile(r"(author:(?P[^ ]+)|title:(?P[^ ]+)|categories:(?P<categories>[^ ]+)|description:(?P<description>[^ ]+))") def get_object(self, request): - return request.GET.get('q', '') + """ + For OPDS 1.1 We should handle a query for search terms + and criteria provided either as opensearch or 'inline' query. + OpenSearch defines fields: atom:author, atom:contributor (treated as translator), + atom:title. Inline query provides author, title, categories (treated as book tags), + description (treated as content search terms). + + if search terms are provided, we shall search for books + according to Hint information (from author & contributror & title). + + but if search terms are empty, we should do a different search + (perhaps for is_book=True) + + """ + JVM.attachCurrentThread() + + query = request.GET.get('q', '') + + inline_criteria = re.findall(self.INLINE_QUERY_RE, query) + if inline_criteria: + def get_criteria(criteria, name, position): + e = filter(lambda el: el[0][0:len(name)] == name, criteria) + log.info("get_criteria: %s" % e) + if not e: + return None + c = e[0][position] + log.info("get_criteria: %s" % c) + if c[0] == '"' and c[-1] == '"': + c = c[1:-1] + c = c.replace('+', ' ') + return c + + author = get_criteria(inline_criteria, 'author', 1) + title = get_criteria(inline_criteria, 'title', 2) + translator = None + categories = get_criteria(inline_criteria, 'categories', 3) + query = get_criteria(inline_criteria, 'description', 4) + else: + author = request.GET.get('author', '') + title = request.GET.get('title', '') + translator = request.GET.get('translator', '') + + # Our client didn't handle the opds placeholders + if author == '{atom:author}': author = '' + if title == '{atom:title}': title = '' + if translator == '{atom:contributor}': translator = '' + categories = None + fuzzy = False + + srch = get_search() + hint = srch.hint() + + # Scenario 1: full search terms provided. + # Use auxiliarry information to narrow it and make it better. + if query: + filters = [] + + if author: + log.info( "narrow to author %s" % author) + hint.tags(srch.search_tags(srch.make_phrase(srch.get_tokens(author, field='authors'), field='authors'), + filt=srch.term_filter(Term('tag_category', 'author')))) + + if translator: + log.info( "filter by translator %s" % translator) + filters.append(QueryWrapperFilter( + srch.make_phrase(srch.get_tokens(translator, field='translators'), + field='translators'))) + + if categories: + filters.append(QueryWrapperFilter( + srch.make_phrase(srch.get_tokens(categories, field="tag_name_pl"), + field='tag_name_pl'))) + + flt = srch.chain_filters(filters) + if title: + log.info( "hint by book title %s" % title) + q = srch.make_phrase(srch.get_tokens(title, field='title'), field='title') + hint.books(*srch.search_books(q, filt=flt)) + + toks = srch.get_tokens(query) + log.info("tokens for query: %s" % toks) + + results = SearchResult.aggregate(srch.search_perfect_book(toks, fuzzy=fuzzy, hint=hint), + srch.search_perfect_parts(toks, fuzzy=fuzzy, hint=hint), + srch.search_everywhere(toks, fuzzy=fuzzy, hint=hint)) + results.sort(reverse=True) + books = [] + for r in results: + try: + books.append(r.book) + except Book.DoesNotExist: + pass + log.info("books: %s" % books) + return books + else: + # Scenario 2: since we no longer have to figure out what the query term means to the user, + # we can just use filters and not the Hint class. + filters = [] + + fields = { + 'author': author, + 'translators': translator, + 'title': title + } + + for fld, q in fields.items(): + if q: + filters.append(QueryWrapperFilter( + srch.make_phrase(srch.get_tokens(q, field=fld), field=fld))) + + flt = srch.chain_filters(filters) + books = srch.search_books(TermQuery(Term('is_book', 'true')), filt=flt) + return books def get_link(self, query): - return "%s?q=%s" % (reverse('search'), query) + return "%s?q=%s" % (reverse('search'), query) - def items(self, query): + def items(self, books): try: - return books_starting_with(query) + return books except ValueError: # too short a query return []