Preserve the weirdness of the API.
[wolnelektury.git] / src / api / handlers.py
index d32981e..7178b9f 100644 (file)
@@ -16,11 +16,11 @@ from piston.utils import rc
 from sorl.thumbnail import default
 
 from api.models import BookUserData
+from catalogue.api.helpers import books_after, order_books
 from catalogue.forms import BookImportForm
-from catalogue.models import Book, Tag, BookMedia, Fragment, Collection
+from catalogue.models import Book, Tag, BookMedia
 from catalogue.models.tag import prefetch_relations
-from catalogue.utils import is_subscribed
-from librarian.cover import WLCover
+from paypal.rest import user_is_subscribed
 from picture.models import Picture
 from picture.forms import PictureImportForm
 from social.utils import likes
@@ -28,13 +28,10 @@ from social.utils import likes
 from stats.utils import piwik_track
 from wolnelektury.utils import re_escape
 
-from . import emitters  # Register our emitters
 
 API_BASE = WL_BASE = MEDIA_BASE = lazy(
     lambda: u'https://' + Site.objects.get_current().domain, unicode)()
 
-SORT_KEY_SEP = '$'
-
 category_singular = {
     'authors': 'author',
     'kinds': 'kind',
@@ -63,6 +60,7 @@ def read_tags(tags, request, allowed):
 
     def process(category, slug):
         if category == 'book':
+            # FIXME: Unused?
             try:
                 books.append(Book.objects.get(slug=slug))
             except Book.DoesNotExist:
@@ -103,25 +101,7 @@ def read_tags(tags, request, allowed):
 # RESTful handlers
 
 
-class BookMediaHandler(BaseHandler):
-    """ Responsible for representing media in Books. """
-
-    model = BookMedia
-    fields = ['name', 'type', 'url', 'artist', 'director']
-
-    @classmethod
-    def url(cls, media):
-        """ Link to media on site. """
-
-        return MEDIA_BASE + media.file.url
-
-    @classmethod
-    def artist(cls, media):
-        return media.extra_info.get('artist_name', '')
 
-    @classmethod
-    def director(cls, media):
-        return media.extra_info.get('director_name', '')
 
 
 class BookDetails(object):
@@ -130,7 +110,7 @@ class BookDetails(object):
     @classmethod
     def href(cls, book):
         """ Returns an URI for a Book in the API. """
-        return API_BASE + reverse("api_book", args=[book.slug])
+        return API_BASE + reverse("catalogue_api_book", args=[book.slug])
 
     @classmethod
     def url(cls, book):
@@ -164,33 +144,6 @@ class BookDetails(object):
     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.get('epoch'), '#000000')
-
-    @classmethod
-    def full_sort_key(cls, book):
-        return '%s%s%s%s%s' % (book.sort_key_author, SORT_KEY_SEP, book.sort_key, SORT_KEY_SEP, book.id)
-
-    @staticmethod
-    def books_after(books, after, new_api):
-        if not new_api:
-            return books.filter(slug__gt=after)
-        try:
-            author, title, book_id = after.split(SORT_KEY_SEP)
-        except ValueError:
-            return Book.objects.none()
-        return books.filter(Q(sort_key_author__gt=author)
-                            | (Q(sort_key_author=author) & Q(sort_key__gt=title))
-                            | (Q(sort_key_author=author) & Q(sort_key=title) & Q(id__gt=int(book_id))))
-
-    @staticmethod
-    def order_books(books, new_api):
-        if new_api:
-            return books.order_by('sort_key_author', 'sort_key', 'id')
-        else:
-            return books.order_by('slug')
-
 
 class BookDetailHandler(BaseHandler, BookDetails):
     """ Main handler for Book objects.
@@ -221,6 +174,7 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
     model = Book
     fields = book_list_fields
 
+    # FIXME: Unused?
     @classmethod
     def genres(cls, book):
         """ Returns all media for a book. """
@@ -239,6 +193,7 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
              are returned.
         """
         if pk is not None:
+            # FIXME: Unused?
             try:
                 return Book.objects.get(pk=pk)
             except Book.DoesNotExist:
@@ -263,7 +218,7 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
                 books = Book.tagged.with_all(tags)
         else:
             books = books if books is not None else Book.objects.all()
-        books = self.order_books(books, new_api)
+        books = order_books(books, new_api)
 
         if top_level:
             books = books.filter(parent=None)
@@ -277,7 +232,7 @@ class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
             books = books.order_by('-created_at')
 
         if after:
-            books = self.books_after(books, after, new_api)
+            books = books_after(books, after, new_api)
 
         if new_api:
             books = books.only('slug', 'title', 'cover', 'cover_thumb', 'sort_key', 'sort_key_author')
@@ -328,18 +283,6 @@ class BooksHandler(BookDetailHandler):
             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):
     fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats) + ('slug',)
 
@@ -387,7 +330,7 @@ class AnonFilterBooksHandler(AnonymousBooksHandler):
         new_api = request.GET.get('new_api')
         after = request.GET.get('after')
         count = int(request.GET.get('count', 50))
-        books = self.order_books(Book.objects.distinct(), new_api)
+        books = order_books(Book.objects.distinct(), new_api)
         if is_lektura is not None:
             books = books.filter(has_audience=is_lektura)
         if is_audiobook is not None:
@@ -414,15 +357,15 @@ class AnonFilterBooksHandler(AnonymousBooksHandler):
             if after and (key_sep in after):
                 which, key = after.split(key_sep, 1)
                 if which == 'title':
-                    book_lists = [(self.books_after(books_title, key, new_api), 'title')]
+                    book_lists = [(books_after(books_title, key, new_api), 'title')]
                 else:  # which == 'author'
-                    book_lists = [(self.books_after(books_author, key, new_api), 'author'), (books_title, 'title')]
+                    book_lists = [(books_after(books_author, key, new_api), 'author'), (books_title, 'title')]
             else:
                 book_lists = [(books_author, 'author'), (books_title, 'title')]
         else:
             if after and key_sep in after:
                 which, key = after.split(key_sep, 1)
-                books = self.books_after(books, key, new_api)
+                books = books_after(books, key, new_api)
             book_lists = [(books, 'book')]
 
         filtered_books = []
@@ -433,7 +376,7 @@ class AnonFilterBooksHandler(AnonymousBooksHandler):
             remaining_count = count - len(filtered_books)
             new_books = [
                 BookProxy(book, '%s%s%s' % (
-                    label, key_sep, book.slug if not new_api else self.full_sort_key(book)))
+                    label, key_sep, book.slug if not new_api else book.full_sort_key()))
                 for book in book_list[:remaining_count]]
             filtered_books += new_books
             if len(filtered_books) == count:
@@ -459,13 +402,6 @@ class FilterBooksHandler(BooksHandler):
         return qsp
 
 
-class BookPreviewHandler(BookDetailHandler):
-    fields = BookDetailHandler.fields + ['slug']
-
-    def read(self, request):
-        return Book.objects.filter(preview=True)
-
-
 # add categorized tags fields for Book
 def _tags_getter(category):
     @classmethod
@@ -511,198 +447,6 @@ def add_file_getters():
 add_file_getters()
 
 
-class CollectionDetails(object):
-    """Custom Collection fields."""
-
-    @classmethod
-    def href(cls, collection):
-        """ Returns URI in the API for the collection. """
-
-        return API_BASE + reverse("api_collection", args=[collection.slug])
-
-    @classmethod
-    def url(cls, collection):
-        """ Returns URL on the site. """
-
-        return WL_BASE + collection.get_absolute_url()
-
-    @classmethod
-    def books(cls, collection):
-        return Book.objects.filter(collection.get_query())
-
-
-class CollectionDetailHandler(BaseHandler, CollectionDetails):
-    allowed_methods = ('GET',)
-    fields = ['url', 'title', 'description', 'books']
-
-    @piwik_track
-    def read(self, request, slug):
-        """ Returns details of a collection, identified by slug. """
-        try:
-            return Collection.objects.get(slug=slug)
-        except Collection.DoesNotExist:
-            return rc.NOT_FOUND
-
-
-class CollectionsHandler(BaseHandler, CollectionDetails):
-    allowed_methods = ('GET',)
-    model = Collection
-    fields = ['url', 'href', 'title']
-
-    @piwik_track
-    def read(self, request):
-        """ Returns all collections. """
-        return Collection.objects.all()
-
-
-class TagDetails(object):
-    """Custom Tag fields."""
-
-    @classmethod
-    def href(cls, tag):
-        """ Returns URI in the API for the tag. """
-
-        return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
-
-    @classmethod
-    def url(cls, tag):
-        """ Returns URL on the site. """
-
-        return WL_BASE + tag.get_absolute_url()
-
-
-class TagDetailHandler(BaseHandler, TagDetails):
-    """ Responsible for details of a single Tag object. """
-
-    fields = ['name', 'url', 'sort_key', 'description']
-
-    @piwik_track
-    def read(self, request, category, slug):
-        """ Returns details of a tag, identified by category and slug. """
-
-        try:
-            category_sng = category_singular[category]
-        except KeyError:
-            return rc.NOT_FOUND
-
-        try:
-            return Tag.objects.get(category=category_sng, slug=slug)
-        except Tag.DoesNotExist:
-            return rc.NOT_FOUND
-
-
-class TagsHandler(BaseHandler, TagDetails):
-    """ Main handler for Tag objects.
-
-    Responsible for lists of Tag objects
-    and fields used for representing Tags.
-
-    """
-    allowed_methods = ('GET',)
-    model = Tag
-    fields = ['name', 'href', 'url', 'slug']
-
-    @piwik_track
-    def read(self, request, category=None, pk=None):
-        """ Lists all tags in the category (eg. all themes). """
-        if pk is not None:
-            try:
-                return Tag.objects.exclude(category='set').get(pk=pk)
-            except Book.DoesNotExist:
-                return rc.NOT_FOUND
-
-        try:
-            category_sng = category_singular[category]
-        except KeyError:
-            return rc.NOT_FOUND
-
-        after = request.GET.get('after')
-        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 count:
-            tags = tags[:count]
-
-        return tags
-
-
-class FragmentDetails(object):
-    """Custom Fragment fields."""
-
-    @classmethod
-    def href(cls, fragment):
-        """ Returns URI in the API for the fragment. """
-
-        return API_BASE + reverse("api_fragment", args=[fragment.book.slug, fragment.anchor])
-
-    @classmethod
-    def url(cls, fragment):
-        """ Returns URL on the site for the fragment. """
-
-        return WL_BASE + fragment.get_absolute_url()
-
-    @classmethod
-    def themes(cls, fragment):
-        """ Returns a list of theme tags for the fragment. """
-
-        return fragment.tags.filter(category='theme')
-
-
-class FragmentDetailHandler(BaseHandler, FragmentDetails):
-    fields = ['book', 'anchor', 'text', 'url', 'themes']
-
-    @piwik_track
-    def read(self, request, book, anchor):
-        """ Returns details of a fragment, identified by book slug and anchor. """
-        try:
-            return Fragment.objects.get(book__slug=book, anchor=anchor)
-        except Fragment.DoesNotExist:
-            return rc.NOT_FOUND
-
-
-class FragmentsHandler(BaseHandler, FragmentDetails):
-    """ Main handler for Fragments.
-
-    Responsible for lists of Fragment objects
-    and fields used for representing Fragments.
-
-    """
-    model = Fragment
-    fields = ['book', 'url', 'anchor', 'href']
-    allowed_methods = ('GET',)
-
-    categories = {'author', 'epoch', 'kind', 'genre', 'book', 'theme'}
-
-    @piwik_track
-    def read(self, request, tags):
-        """ Lists all fragments with given book, tags, themes.
-
-        :param tags: should be a path of categories and slugs, i.e.:
-             books/book-slug/authors/an-author/themes/a-theme/
-
-        """
-        try:
-            tags, ancestors = read_tags(tags, request, allowed=self.categories)
-        except ValueError:
-            return rc.NOT_FOUND
-        fragments = Fragment.tagged.with_all(tags).select_related('book')
-        if fragments.exists():
-            return fragments
-        else:
-            return rc.NOT_FOUND
-
-
 class PictureHandler(BaseHandler):
     model = Picture
     fields = ('slug', 'title')
@@ -721,109 +465,6 @@ class PictureHandler(BaseHandler):
             return rc.NOT_FOUND
 
 
-class UserDataHandler(BaseHandler):
-    model = BookUserData
-    fields = ('state', 'username', 'premium')
-    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, 'premium': is_subscribed(request.user)}
-        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_list_fields + ['liked']
-
-    def parse_bool(self, s):
-        if s in ('true', 'false'):
-            return s == 'true'
-        else:
-            return None
-
-    # hack, because piston is stupid
-    @classmethod
-    def liked(cls, book):
-        return getattr(book, 'liked', None)
-
-    def read(self, request, state):
-        if not request.user.is_authenticated():
-            return rc.FORBIDDEN
-        likes = set(Book.tagged.with_any(request.user.tag_set.all()).values_list('id', flat=True))
-        if state not in ('reading', 'complete', 'likes'):
-            return rc.NOT_FOUND
-        new_api = request.GET.get('new_api')
-        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()
-            books = self.order_books(books, new_api)
-        if after:
-            books = self.books_after(books, after, new_api)
-        if count:
-            books = books[:count]
-        new_books = []
-        for book in books:
-            new_books.append(BookProxy(book).set('liked', book.id in likes))
-        return QuerySetProxy(new_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 = (