form for #cojaczytam

[wolnelektury.git] / src / api / handlers.py

diff --git a/src/api/handlers.py b/src/api/handlers.py
index b81afda..af01337 100644 (file)
--- a/src/api/handlers.py
+++ b/src/api/handlers.py
@@ -6,17 +6,26 @@ import json
 
 from django.contrib.sites.models import Site
 from django.core.urlresolvers import reverse
 
 from django.contrib.sites.models import Site
 from django.core.urlresolvers import reverse

+from django.http.response import HttpResponse

 from django.utils.functional import lazy
 from django.utils.functional import lazy

+from django.db import models
+from migdal.models import Entry

 from piston.handler import AnonymousBaseHandler, BaseHandler
 from piston.utils import rc
 from sorl.thumbnail import default
 
 from piston.handler import AnonymousBaseHandler, BaseHandler
 from piston.utils import rc
 from sorl.thumbnail import default
 

+from api.models import BookUserData

 from catalogue.forms import BookImportForm
 from catalogue.models import Book, Tag, BookMedia, Fragment, Collection
 from catalogue.forms import BookImportForm
 from catalogue.models import Book, Tag, BookMedia, Fragment, Collection

+from catalogue.models.tag import prefetch_relations
+from catalogue.utils import is_subscribed
+from librarian.cover import WLCover

 from picture.models import Picture
 from picture.forms import PictureImportForm
 from picture.models import Picture
 from picture.forms import PictureImportForm

+from social.utils import likes

 
 from stats.utils import piwik_track
 
 from stats.utils import piwik_track

+from wolnelektury.utils import re_escape

 
 from . import emitters  # Register our emitters
 
 
 from . import emitters  # Register our emitters
 


@@ -39,13 +48,25 @@ for k, v in category_singular.items():
 book_tag_categories = ['author', 'epoch', 'kind', 'genre']
 
 
 book_tag_categories = ['author', 'epoch', 'kind', 'genre']
 
 

-def read_tags(tags, allowed):
+def read_tags(tags, request, allowed):

     """ Reads a path of filtering tags.
 
     :param str tags: a path of category and slug pairs, like: authors/an-author/...
     :returns: list of Tag objects
     :raises: ValueError when tags can't be found
     """
     """ Reads a path of filtering tags.
 
     :param str tags: a path of category and slug pairs, like: authors/an-author/...
     :returns: list of Tag objects
     :raises: ValueError when tags can't be found
     """

+
+    def process(category, slug):
+        if category == 'book':
+            try:
+                books.append(Book.objects.get(slug=slug))
+            except Book.DoesNotExist:
+                raise ValueError('Unknown book.')
+        try:
+            real_tags.append(Tag.objects.get(category=category, slug=slug))
+        except Tag.DoesNotExist:
+            raise ValueError('Tag not found')
+

     if not tags:
         return [], []
 
     if not tags:
         return [], []
 


@@ -63,17 +84,14 @@ def read_tags(tags, allowed):
 
         if category not in allowed:
             raise ValueError('Category not allowed.')
 
         if category not in allowed:
             raise ValueError('Category not allowed.')

-
-        if category == 'book':
-            try:
-                books.append(Book.objects.get(slug=slug))
-            except Book.DoesNotExist:
-                raise ValueError('Unknown book.')
-
-        try:
-            real_tags.append(Tag.objects.get(category=category, slug=slug))
-        except Tag.DoesNotExist:
-            raise ValueError('Tag not found')
+        process(category, slug)
+
+    for key in request.GET:
+        if key in category_singular:
+            category = category_singular[key]
+            if category in allowed:
+                for slug in request.GET.getlist(key):
+                    process(category, slug)

     return real_tags, books
 
 
     return real_tags, books
 
 


@@ -112,14 +130,12 @@ class BookDetails(object):
     @classmethod
     def url(cls, book):
         """ Returns Book's URL on the site. """
     @classmethod
     def url(cls, book):
         """ Returns Book's URL on the site. """

-

         return WL_BASE + book.get_absolute_url()
 
     @classmethod
     def children(cls, book):
         """ Returns all children for a book. """
         return WL_BASE + book.get_absolute_url()
 
     @classmethod
     def children(cls, book):
         """ Returns all children for a book. """

-
-        return book.children.all()
+        return book.children.order_by('parent_number', 'sort_key')

 
     @classmethod
     def media(cls, book):
 
     @classmethod
     def media(cls, book):


@@ -135,6 +151,18 @@ class BookDetails(object):
         return MEDIA_BASE + default.backend.get_thumbnail(
                     book.cover, "139x193").url if book.cover else ''
 
         return MEDIA_BASE + default.backend.get_thumbnail(
                     book.cover, "139x193").url if book.cover else ''
 

+    @classmethod
+    def simple_thumb(cls, book):
+        return MEDIA_BASE + book.cover_api_thumb.url if book.cover_api_thumb else ''
+
+    @classmethod
+    def simple_cover(cls, book):
+        return MEDIA_BASE + book.simple_cover.url if book.simple_cover else ''
+
+    @classmethod
+    def cover_color(cls, book):
+        return WLCover.epoch_colors.get(book.extra_info['epoch'], '#000000')
+

 
 class BookDetailHandler(BaseHandler, BookDetails):
     """ Main handler for Book objects.
 
 class BookDetailHandler(BaseHandler, BookDetails):
     """ Main handler for Book objects.


@@ -143,7 +171,8 @@ class BookDetailHandler(BaseHandler, BookDetails):
     """
     allowed_methods = ['GET']
     fields = ['title', 'parent', 'children'] + Book.formats + [
     """
     allowed_methods = ['GET']
     fields = ['title', 'parent', 'children'] + Book.formats + [

-        'media', 'url', 'cover', 'cover_thumb'] + [
+        'media', 'url', 'cover', 'cover_thumb', 'simple_thumb', 'simple_cover', 'fragment_data', 'audio_length',
+        'preview', 'cover_color'] + [

             category_plural[c] for c in book_tag_categories]
 
     @piwik_track
             category_plural[c] for c in book_tag_categories]
 
     @piwik_track


@@ -162,7 +191,8 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
     """
     allowed_methods = ('GET',)
     model = Book
     """
     allowed_methods = ('GET',)
     model = Book

-    fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
+    fields = book_tag_categories + [
+        'href', 'title', 'url', 'cover', 'cover_thumb', 'slug', 'simple_thumb', 'has_audio', 'cover_color']

 
     @classmethod
     def genres(cls, book):
 
     @classmethod
     def genres(cls, book):


@@ -170,7 +200,9 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
         return book.tags.filter(category='genre')
 
     @piwik_track
         return book.tags.filter(category='genre')
 
     @piwik_track

-    def read(self, request, tags=None, top_level=False, audiobooks=False, daisy=False, pk=None):
+    def read(self, request, tags=None, top_level=False, audiobooks=False, daisy=False, pk=None,
+             recommended=False, newest=False, books=None,
+             after=None, before=None, count=None):

         """ Lists all books with given tags.
 
         :param tags: filtering tags; should be a path of categories
         """ Lists all books with given tags.
 
         :param tags: filtering tags; should be a path of categories


@@ -186,10 +218,17 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
                 return rc.NOT_FOUND
 
         try:
                 return rc.NOT_FOUND
 
         try:

-            tags, _ancestors = read_tags(tags, allowed=book_tag_categories)
+            tags, _ancestors = read_tags(tags, request, allowed=book_tag_categories)

         except ValueError:
             return rc.NOT_FOUND
 
         except ValueError:
             return rc.NOT_FOUND
 

+        if 'after' in request.GET:
+            after = request.GET['after']
+        if 'before' in request.GET:
+            before = request.GET['before']
+        if 'count' in request.GET:
+            count = request.GET['count']
+

         if tags:
             if top_level:
                 books = Book.tagged_top_level(tags)
         if tags:
             if top_level:
                 books = Book.tagged_top_level(tags)


@@ -197,7 +236,8 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
             else:
                 books = Book.tagged.with_all(tags)
         else:
             else:
                 books = Book.tagged.with_all(tags)
         else:

-            books = Book.objects.all()
+            books = books if books is not None else Book.objects.all()
+        books = books.order_by('slug')

 
         if top_level:
             books = books.filter(parent=None)
 
         if top_level:
             books = books.filter(parent=None)


@@ -205,13 +245,27 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
             books = books.filter(media__type='mp3').distinct()
         if daisy:
             books = books.filter(media__type='daisy').distinct()
             books = books.filter(media__type='mp3').distinct()
         if daisy:
             books = books.filter(media__type='daisy').distinct()

+        if recommended:
+            books = books.filter(recommended=True)
+        if newest:
+            books = books.order_by('-created_at')
+
+        if after:
+            books = books.filter(slug__gt=after)
+        if before:
+            books = books.filter(slug__lt=before)
+
+        books = books.only('slug', 'title', 'cover', 'cover_thumb')
+        for category in book_tag_categories:
+            books = prefetch_relations(books, category)
+
+        if count:
+            if before:
+                books = list(reversed(books.order_by('-slug')[:count]))
+            else:
+                books = books[:count]

 
 

-        books = books.only('slug', 'title', 'cover')
-
-        if books:
-            return books
-        else:
-            return rc.NOT_FOUND
+        return books

 
     def create(self, request, *args, **kwargs):
         return rc.FORBIDDEN
 
     def create(self, request, *args, **kwargs):
         return rc.FORBIDDEN


@@ -220,7 +274,7 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
 class BooksHandler(BookDetailHandler):
     allowed_methods = ('GET', 'POST')
     model = Book
 class BooksHandler(BookDetailHandler):
     allowed_methods = ('GET', 'POST')
     model = Book

-    fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
+    fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb', 'cover_color', 'slug']

     anonymous = AnonymousBooksHandler
 
     def create(self, request, *args, **kwargs):
     anonymous = AnonymousBooksHandler
 
     def create(self, request, *args, **kwargs):


@@ -236,8 +290,120 @@ class BooksHandler(BookDetailHandler):
             return rc.NOT_FOUND
 
 
             return rc.NOT_FOUND
 
 

+class EpubHandler(BookDetailHandler):
+    def read(self, request, slug):
+        if not is_subscribed(request.user):
+            return rc.FORBIDDEN
+        try:
+            book = Book.objects.get(slug=slug)
+        except Book.DoesNotExist:
+            return rc.NOT_FOUND
+        response = HttpResponse(book.get_media('epub'))
+        return response
+
+

 class EBooksHandler(AnonymousBooksHandler):
 class EBooksHandler(AnonymousBooksHandler):

-    fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats)
+    fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats) + ('slug',)
+
+
+class BookProxy(models.Model):
+    class Meta:
+        managed = False
+
+    def __init__(self, book, key):
+        self.book = book
+        self.key = key
+
+    def __getattr__(self, item):
+        if item not in ('book', 'key'):
+            return self.book.__getattribute__(item)
+        else:
+            return self.__getattribute__(item)
+
+
+class QuerySetProxy(models.QuerySet):
+    def __init__(self, l):
+        self.list = l
+
+    def __iter__(self):
+        return iter(self.list)
+
+
+class FilterBooksHandler(AnonymousBooksHandler):
+    fields = book_tag_categories + [
+        'href', 'title', 'url', 'cover', 'cover_thumb', 'cover_color', 'simple_thumb', 'has_audio', 'slug', 'key']
+
+    def parse_bool(self, s):
+        if s in ('true', 'false'):
+            return s == 'true'
+        else:
+            return None
+
+    def read(self, request):
+        key_sep = '$'
+        search_string = request.GET.get('search')
+        is_lektura = self.parse_bool(request.GET.get('lektura'))
+        is_audiobook = self.parse_bool(request.GET.get('audiobook'))
+        preview = self.parse_bool(request.GET.get('preview'))
+
+        after = request.GET.get('after')
+        count = int(request.GET.get('count', 50))
+        books = Book.objects.distinct().order_by('slug')
+        if is_lektura is not None:
+            books = books.filter(has_audience=is_lektura)
+        if is_audiobook is not None:
+            if is_audiobook:
+                books = books.filter(media__type='mp3')
+            else:
+                books = books.exclude(media__type='mp3')
+        if preview is not None:
+            books = books.filter(preview=preview)
+        for key in request.GET:
+            if key in category_singular:
+                category = category_singular[key]
+                if category in book_tag_categories:
+                    slugs = request.GET[key].split(',')
+                    tags = Tag.objects.filter(category=category, slug__in=slugs)
+                    books = Book.tagged.with_any(tags, books)
+        if (search_string is not None) and len(search_string) < 3:
+            search_string = None
+        if search_string:
+            search_string = re_escape(search_string)
+            books_author = books.filter(cached_author__iregex='\m' + search_string)
+            books_title = books.filter(title__iregex='\m' + search_string)
+            books_title = books_title.exclude(id__in=list(books_author.values_list('id', flat=True)))
+            if after and (key_sep in after):
+                which, slug = after.split(key_sep, 1)
+                if which == 'title':
+                    book_lists = [(books_title.filter(slug__gt=slug), 'title')]
+                else:  # which == 'author'
+                    book_lists = [(books_author.filter(slug__gt=slug), 'author'), (books_title, 'title')]
+            else:
+                book_lists = [(books_author, 'author'), (books_title, 'title')]
+        else:
+            if after and key_sep in after:
+                which, slug = after.split(key_sep, 1)
+                books = books.filter(slug__gt=slug)
+            book_lists = [(books, 'book')]
+
+        filtered_books = []
+        for book_list, label in book_lists:
+            book_list = book_list.only('slug', 'title', 'cover', 'cover_thumb')
+            for category in book_tag_categories:
+                book_list = prefetch_relations(book_list, category)
+            remaining_count = count - len(filtered_books)
+            new_books = [BookProxy(book, '%s%s%s' % (label, key_sep, book.slug))
+                         for book in book_list[:remaining_count]]
+            filtered_books += new_books
+            if len(filtered_books) == count:
+                break
+
+        return QuerySetProxy(filtered_books)
+
+
+class BookPreviewHandler(BookDetailHandler):
+    def read(self, request):
+        return Book.objects.filter(preview=True)

 
 
 # add categorized tags fields for Book
 
 
 # add categorized tags fields for Book


@@ -251,7 +417,7 @@ def _tags_getter(category):
 def _tag_getter(category):
     @classmethod
     def get_tag(cls, book):
 def _tag_getter(category):
     @classmethod
     def get_tag(cls, book):

-        return ', '.join(book.tags.filter(category=category).values_list('name', flat=True))
+        return book.tag_unicode(category)

     return get_tag
 
 
     return get_tag
 
 


@@ -260,18 +426,18 @@ def add_tag_getters():
         setattr(BookDetails, plural, _tags_getter(singular))
         setattr(BookDetails, singular, _tag_getter(singular))
 
         setattr(BookDetails, plural, _tags_getter(singular))
         setattr(BookDetails, singular, _tag_getter(singular))
 

+

 add_tag_getters()
 
 
 # add fields for files in Book
 def _file_getter(book_format):
 add_tag_getters()
 
 
 # add fields for files in Book
 def _file_getter(book_format):

-    field = "%s_file" % book_format

 
 

-    @classmethod
-    def get_file(cls, book):
-        f = getattr(book, field)
-        if f:
-            return MEDIA_BASE + f.url
+    @staticmethod
+    def get_file(book):
+        f_url = book.media_url(book_format)
+        if f_url:
+            return MEDIA_BASE + f_url

         else:
             return ''
     return get_file
         else:
             return ''
     return get_file


@@ -281,6 +447,7 @@ def add_file_getters():
     for book_format in Book.formats:
         setattr(BookDetails, book_format, _file_getter(book_format))
 
     for book_format in Book.formats:
         setattr(BookDetails, book_format, _file_getter(book_format))
 

+

 add_file_getters()
 
 
 add_file_getters()
 
 


@@ -373,7 +540,7 @@ class TagsHandler(BaseHandler, TagDetails):
     """
     allowed_methods = ('GET',)
     model = Tag
     """
     allowed_methods = ('GET',)
     model = Tag

-    fields = ['name', 'href', 'url']
+    fields = ['name', 'href', 'url', 'slug']

 
     @piwik_track
     def read(self, request, category=None, pk=None):
 
     @piwik_track
     def read(self, request, category=None, pk=None):


@@ -389,11 +556,31 @@ class TagsHandler(BaseHandler, TagDetails):
         except KeyError:
             return rc.NOT_FOUND
 
         except KeyError:
             return rc.NOT_FOUND
 

-        tags = Tag.objects.filter(category=category_sng).exclude(items=None)
-        if tags.exists():
-            return tags
-        else:
-            return rc.NOT_FOUND
+        after = request.GET.get('after')
+        before = request.GET.get('before')
+        count = request.GET.get('count')
+
+        tags = Tag.objects.filter(category=category_sng).exclude(items=None).order_by('slug')
+
+        book_only = request.GET.get('book_only') == 'true'
+        picture_only = request.GET.get('picture_only') == 'true'
+        if book_only:
+            tags = tags.filter(for_books=True)
+        if picture_only:
+            tags = tags.filter(for_pictures=True)
+
+        if after:
+            tags = tags.filter(slug__gt=after)
+        if before:
+            tags = tags.filter(slug__lt=before)
+
+        if count:
+            if before:
+                tags = list(reversed(tags.order_by('-slug')[:count]))
+            else:
+                tags = tags[:count]
+
+        return tags

 
 
 class FragmentDetails(object):
 
 
 class FragmentDetails(object):


@@ -452,7 +639,7 @@ class FragmentsHandler(BaseHandler, FragmentDetails):
 
         """
         try:
 
         """
         try:

-            tags, ancestors = read_tags(tags, allowed=self.categories)
+            tags, ancestors = read_tags(tags, request, allowed=self.categories)

         except ValueError:
             return rc.NOT_FOUND
         fragments = Fragment.tagged.with_all(tags).select_related('book')
         except ValueError:
             return rc.NOT_FOUND
         fragments = Fragment.tagged.with_all(tags).select_related('book')


@@ -478,3 +665,123 @@ class PictureHandler(BaseHandler):
             return rc.CREATED
         else:
             return rc.NOT_FOUND
             return rc.CREATED
         else:
             return rc.NOT_FOUND

+
+
+class UserDataHandler(BaseHandler):
+    model = BookUserData
+    fields = ('state', 'username')
+    allowed_methods = ('GET', 'POST')
+
+    def read(self, request, slug=None):
+        if not request.user.is_authenticated():
+            return rc.FORBIDDEN
+        if slug is None:
+            return {'username': request.user.username}
+        try:
+            book = Book.objects.get(slug=slug)
+        except Book.DoesNotExist:
+            return rc.NOT_FOUND
+        try:
+            data = BookUserData.objects.get(book=book, user=request.user)
+        except BookUserData.DoesNotExist:
+            return {'state': 'not_started'}
+        return data
+
+    def create(self, request, slug, state):
+        try:
+            book = Book.objects.get(slug=slug)
+        except Book.DoesNotExist:
+            return rc.NOT_FOUND
+        if not request.user.is_authenticated():
+            return rc.FORBIDDEN
+        if state not in ('reading', 'complete'):
+            return rc.NOT_FOUND
+        data, created = BookUserData.objects.get_or_create(book=book, user=request.user)
+        data.state = state
+        data.save()
+        return data
+
+
+class UserShelfHandler(BookDetailHandler):
+    fields = book_tag_categories + [
+        'href', 'title', 'url', 'cover', 'cover_thumb', 'simple_thumb', 'slug', 'key']
+
+    def parse_bool(self, s):
+        if s in ('true', 'false'):
+            return s == 'true'
+        else:
+            return None
+
+    def read(self, request, state):
+        if not request.user.is_authenticated():
+            return rc.FORBIDDEN
+        if state not in ('reading', 'complete', 'likes'):
+            return rc.NOT_FOUND
+        after = request.GET.get('after')
+        count = int(request.GET.get('count', 50))
+        if state == 'likes':
+            books = Book.tagged.with_any(request.user.tag_set.all())
+        else:
+            ids = BookUserData.objects.filter(user=request.user, complete=state == 'complete')\
+                .values_list('book_id', flat=True)
+            books = Book.objects.filter(id__in=list(ids)).distinct().order_by('slug')
+        if after:
+            books = books.filter(slug__gt=after)
+        if count:
+            books = books[:count]
+        return books
+
+
+class UserLikeHandler(BaseHandler):
+    fields = []
+    allowed_methods = ('GET', 'POST')
+
+    def read(self, request, slug):
+        if not request.user.is_authenticated():
+            return rc.FORBIDDEN
+        try:
+            book = Book.objects.get(slug=slug)
+        except Book.DoesNotExist:
+            return rc.NOT_FOUND
+        return {'likes': likes(request.user, book)}
+
+    def create(self, request, slug):
+        if not request.user.is_authenticated():
+            return rc.FORBIDDEN
+        try:
+            book = Book.objects.get(slug=slug)
+        except Book.DoesNotExist:
+            return rc.NOT_FOUND
+        action = request.GET.get('action', 'like')
+        if action == 'like':
+            book.like(request.user)
+        elif action == 'unlike':
+            book.unlike(request.user)
+        return {}
+
+
+class BlogEntryHandler(BaseHandler):
+    model = Entry
+    fields = ('title', 'lead', 'body', 'place', 'time', 'image_url', 'gallery_urls', 'type', 'key')
+
+    def read(self, request):
+        after = request.GET.get('after')
+        count = int(request.GET.get('count', 20))
+        entries = Entry.published_objects.filter(in_stream=True).order_by('-first_published_at')
+        if after:
+            entries = entries.filter(first_published_at__lt=after)
+        if count:
+            entries = entries[:count]
+        return entries
+
+    @classmethod
+    def image_url(cls, entry):
+        return entry.image.url if entry.image else None
+
+    @classmethod
+    def gallery_urls(cls, entry):
+        return [photo.url() for photo in entry.photo_set.all()]
+
+    @classmethod
+    def key(cls, entry):
+        return entry.first_published_at