X-Git-Url: https://git.mdrn.pl/wolnelektury.git/blobdiff_plain/d467f1fa349730919e9fe906287e63563c888063..fda9072f7469fc178347e74fb6ff9309c98a94d0:/apps/catalogue/views.py

diff --git a/apps/catalogue/views.py b/apps/catalogue/views.py
index de72b046a..aaf57fc47 100644
--- a/apps/catalogue/views.py
+++ b/apps/catalogue/views.py
@@ -26,6 +26,7 @@ from django.utils.encoding import force_unicode
 from django.utils.http import urlquote_plus
 from django.views.decorators import cache
 from django.utils.translation import ugettext as _
+from django.views.generic.list_detail import object_list
 
 from catalogue import models
 from catalogue import forms
@@ -85,7 +86,7 @@ def tagged_object_list(request, tags=''):
     
     theme_is_set = [tag for tag in tags if tag.category == 'theme']
     shelf_is_set = len(tags) == 1 and tags[0].category == 'set'
-    my_shelf_is_set = shelf_is_set and request.user.is_authenticated() and request.user == shelf[0].user
+    my_shelf_is_set = shelf_is_set and request.user.is_authenticated() and request.user == tags[0].user
     
     objects = only_author = pd_counter = categories = None
     
@@ -95,48 +96,40 @@ def tagged_object_list(request, tags=''):
         fragments = models.Fragment.tagged.with_all(fragment_tags)
         
         if shelf_tags:
-            books = models.Book.tagged.with_all(shelf_tags)
+            books = models.Book.tagged.with_all(shelf_tags).order_by()
             l_tags = [models.Tag.objects.get(slug = 'l-' + book.slug) for book in books]
-            fragments = (fragment for fragment in models.Fragment.tagged.with_any(l_tags) if fragment in fragments)
+            fragments = models.Fragment.tagged.with_any(l_tags, fragments)
         
-        fragment_keys = (fragment.pk for fragment in fragments)
-        if fragment_keys:
-            related_tags = models.Fragment.tags.usage(counts=True,
-                                filters={'pk__in': fragment_keys}, 
-                                extra={'where': ["catalogue_tag.category != 'book'"]})
-            related_tags = (tag for tag in related_tags if tag not in fragment_tags)
-            categories = split_tags(related_tags)
-            
-            objects = fragments
+        related_tags = models.Tag.objects.usage_for_queryset(fragments, counts=True, 
+                            extra={'where': ["catalogue_tag.category != 'book'"]})
+        related_tags = (tag for tag in related_tags if tag not in fragment_tags)
+        categories = split_tags(related_tags)
+        
+        objects = fragments
     else:
-        books = models.Book.tagged.with_all(tags)
+        books = models.Book.tagged.with_all(tags).order_by()
         l_tags = [models.Tag.objects.get(slug = 'l-' + book.slug) for book in books]
         book_keys = [book.pk for book in books]
-        if book_keys:
-            related_tags = models.Book.tags.usage(counts=True,
-                                filters={'pk__in': book_keys}, 
-                                extra={'where': ["catalogue_tag.category NOT IN ('set', 'book', 'theme')"]})
-            categories = split_tags(related_tags)
-    
-            fragment_keys = [fragment.pk for fragment in models.Fragment.tagged.with_any(l_tags)]
-            if fragment_keys:
-                categories['theme'] = models.Fragment.tags.usage(counts=True,
-                                    filters={'pk__in': fragment_keys}, 
-                                    extra={'where': ["catalogue_tag.category = 'theme'"]})
-                
-            books = books.exclude(parent__in = book_keys)
-            objects = books
+        related_tags = models.Tag.objects.usage_for_queryset(books, counts=True, 
+                            extra={'where': ["catalogue_tag.category NOT IN ('set', 'book', 'theme')"]})
+        related_tags = (tag for tag in related_tags if tag not in tags)
+        categories = split_tags(related_tags)
+
+        fragments = models.Fragment.tagged.with_any(l_tags)
+        categories['theme'] = models.Tag.objects.usage_for_queryset(fragments, counts=True,  
+                            extra={'where': ["catalogue_tag.category = 'theme'"]})
+            
+        books = books.exclude(parent__in = book_keys)
+        objects = books
         
     if not objects:
         only_author = len(tags) == 1 and tags[0].category == 'author'
         pd_counter = only_author and tags[0].goes_to_pd()
         objects = models.Book.objects.none()
     
-    return newtagging_views.tagged_object_list(
+    return object_list(
         request,
-        tag_model=models.Tag,
-        queryset_or_model=objects,
-        tags=tags,
+        objects,
         template_name='catalogue/tagged_object_list.html',
         extra_context = {
             'categories': categories,
@@ -145,7 +138,9 @@ def tagged_object_list(request, tags=''):
             'pd_counter': pd_counter,
             'user_is_owner': my_shelf_is_set,
             'formats_form': forms.DownloadFormatsForm(),
-        },
+
+            'tags': tags,
+        }
     )
 
 
@@ -209,43 +204,56 @@ def _no_diacritics_regexp(query):
     """ returns a regexp for searching for a query without diacritics
     
     should be locale-aware """
-    names = {'a':u'ą', 'c':u'ć', 'e':u'ę', 'l': u'ł', 'n':u'ń', 'o':u'ó', 's':u'ś', 'z':u'ź|ż'}
+    names = {
+        u'a':u'aąĄ', u'c':u'cćĆ', u'e':u'eęĘ', u'l': u'lłŁ', u'n':u'nńŃ', u'o':u'oóÓ', u's':u'sśŚ', u'z':u'zźżŹŻ',
+        u'ą':u'ąĄ', u'ć':u'ćĆ', u'ę':u'ęĘ', u'ł': u'łŁ', u'ń':u'ńŃ', u'ó':u'óÓ', u'ś':u'śŚ', u'ź':u'źŹ', u'ż':u'żŻ'
+        }
     def repl(m):
         l = m.group()
-        return "(%s|%s)" % (l, names[l])
-    return re.sub('[%s]'%(''.join(names.keys())), repl, query)
+        return u"(%s)" % '|'.join(names[l])
+    return re.sub(u'[%s]'%(u''.join(names.keys())), repl, query)
+
+def unicode_re_escape(query):
+    """ Unicode-friendly version of re.escape """
+    return re.sub('(?u)(\W)', r'\\\1', query)
 
 def _word_starts_with(name, prefix):
     """returns a Q object getting models having `name` contain a word
     starting with `prefix`
+    
+    We define word characters as alphanumeric and underscore, like in JS.
+    
+    Works for MySQL, PostgreSQL, Oracle.
+    For SQLite, _sqlite* version is substituted for this.
     """
     kwargs = {}
-    if settings.DATABASE_ENGINE in ('mysql', 'postgresql_psycopg2', 'postgresql'):
-        prefix = _no_diacritics_regexp(re.escape(prefix))
-        # we could use a [[:<:]] (word start), 
-        # but we want both `xy` and `(xy` to catch `(xyz)`
-        kwargs['%s__iregex' % name] = u"(^|[^[:alpha:]])%s" % prefix
-    else:
-        # don't know how to do a generic regex
-        # checking for simple icontain instead
-        kwargs['%s__icontains' % name] = prefix
+
+    prefix = _no_diacritics_regexp(unicode_re_escape(prefix))
+    # can't use [[:<:]] (word start), 
+    # but we want both `xy` and `(xy` to catch `(xyz)`
+    kwargs['%s__iregex' % name] = u"(^|[^[:alnum:]_])%s" % prefix
+    print kwargs['%s__iregex' % name]
+
     return Q(**kwargs)
 
+    
+def _sqlite_word_starts_with(name, prefix):
+    """ version of _word_starts_with for SQLite 
+    
+    SQLite in Django uses Python re module
+    """
+    kwargs = {}
+    prefix = _no_diacritics_regexp(unicode_re_escape(prefix))
+    kwargs['%s__iregex' % name] = ur"(^|(?<=[^\wąćęłńóśźżĄĆĘŁŃÓŚŹŻ]))%s" % prefix
+    return Q(**kwargs)
 
-def _tags_exact_matches(prefix, user):
-    book_stubs = models.BookStub.objects.filter(title__iexact = prefix)
-    books = models.Book.objects.filter(title__iexact = prefix)
-    book_stubs = filter(lambda x: x not in books, book_stubs)
-    tags = models.Tag.objects.filter(name__iexact = prefix)
-    if user.is_authenticated():
-        tags = tags.filter(~Q(category='book') & (~Q(category='set') | Q(user=user)))
-    else:
-        tags = tags.filter(~Q(category='book') & ~Q(category='set'))
 
-    return list(books) + list(tags) + list(book_stubs)
+if settings.DATABASE_ENGINE == 'sqlite3':
+    _word_starts_with = _sqlite_word_starts_with
 
 
 def _tags_starting_with(prefix, user):
+    prefix = prefix.lower()
     book_stubs = models.BookStub.objects.filter(_word_starts_with('title', prefix))
     books = models.Book.objects.filter(_word_starts_with('title', prefix))
     book_stubs = filter(lambda x: x not in books, book_stubs)
@@ -276,6 +284,29 @@ def _get_result_type(match):
     
 
 
+def find_best_matches(query, user):
+    """ Finds a Book, Tag or Bookstub best matching a query.
+    
+    Returns a with:
+      - zero elements when nothing is found,
+      - one element when a best result is found,
+      - more then one element on multiple exact matches
+    
+    Raises a ValueError on too short a query.
+    """
+    
+    query = query.lower()
+    if len(query) < 2:
+        raise ValueError("query must have at least two characters")
+    
+    result = tuple(_tags_starting_with(query, user))
+    exact_matches = tuple(res for res in result if res.name.lower() == query)
+    if exact_matches:
+        return exact_matches
+    else:
+        return result[:1]    
+
+
 def search(request):
     tags = request.GET.get('tags', '')
     prefix = request.GET.get('q', '')
@@ -284,26 +315,19 @@ def search(request):
         tag_list = models.Tag.get_tag_list(tags)
     except:
         tag_list = []
-
-    # Prefix must have at least 2 characters
-    if len(prefix) < 2:
+    
+    try:
+        result = find_best_matches(prefix, request.user)
+    except ValueError:
         return render_to_response('catalogue/search_too_short.html', {'tags':tag_list, 'prefix':prefix},
             context_instance=RequestContext(request))
-    
-    result = _tags_exact_matches(prefix, request.user)
-    
-    if len(result) > 1:
-        # multiple exact matches
+
+    if len(result) == 1:
+        return HttpResponseRedirect(_get_result_link(result[0], tag_list))
+    elif len(result) > 1:
         return render_to_response('catalogue/search_multiple_hits.html', 
             {'tags':tag_list, 'prefix':prefix, 'results':((x, _get_result_link(x, tag_list), _get_result_type(x)) for x in result)},
             context_instance=RequestContext(request))
-    
-    if not result:
-        # no exact matches
-        result = _tags_starting_with(prefix, request.user)
-    
-    if result:
-        return HttpResponseRedirect(_get_result_link(result[0], tag_list))
     else:
         return render_to_response('catalogue/search_no_hits.html', {'tags':tag_list, 'prefix':prefix},
             context_instance=RequestContext(request))