X-Git-Url: https://git.mdrn.pl/wolnelektury.git/blobdiff_plain/96d13ead60e0c798146ffaadd951877a8077ad9d..919a5d574aac85d55b6cfd17f0a81dd5ff56265a:/apps/api/handlers.py?ds=sidebyside diff --git a/apps/api/handlers.py b/apps/api/handlers.py index f23416751..8f06deafc 100644 --- a/apps/api/handlers.py +++ b/apps/api/handlers.py @@ -3,14 +3,328 @@ # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information. from datetime import datetime, timedelta -from piston.handler import BaseHandler +import json + from django.conf import settings +from django.contrib.sites.models import Site +from django.core.urlresolvers import reverse +from piston.handler import AnonymousBaseHandler, BaseHandler +from piston.utils import rc from api.helpers import timestamp from api.models import Deleted -from catalogue.models import Book, Tag +from catalogue.forms import BookImportForm +from catalogue.models import Book, Tag, BookMedia, Fragment + +from stats.utils import piwik_track + +API_BASE = WL_BASE = MEDIA_BASE = 'http://' + Site.objects.get_current().domain + + +category_singular = { + 'authors': 'author', + 'kinds': 'kind', + 'genres': 'genre', + 'epochs': 'epoch', + 'themes': 'theme', + 'books': 'book', +} +category_plural={} +for k, v in category_singular.items(): + category_plural[v] = k + + +def read_tags(tags, 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 + """ + if not tags: + return [] + + tags = tags.strip('/').split('/') + real_tags = [] + while tags: + category = tags.pop(0) + slug = tags.pop(0) + + try: + category = category_singular[category] + except KeyError: + raise ValueError('Unknown category.') + + if not category in allowed: + raise ValueError('Category not allowed.') + + # !^%@#$^#! + if category == 'book': + slug = 'l-' + slug + + try: + real_tags.append(Tag.objects.get(category=category, slug=slug)) + except Tag.DoesNotExist: + raise ValueError('Tag not found') + return real_tags + + +# RESTful handlers + + +class BookMediaHandler(BaseHandler): + """ Responsible for representing media in Books. """ + + model = BookMedia + fields = ['name', 'type', 'url'] + + @classmethod + def url(cls, media): + """ Link to media on site. """ + + return MEDIA_BASE + media.file.url + + +class BookDetailHandler(BaseHandler): + """ Main handler for Book objects. + + Responsible for lists of Book objects + and fields used for representing Books. + + """ + allowed_methods = ['GET'] + fields = ['title', 'parent'] + Book.file_types + [ + 'media', 'url'] + category_singular.keys() + + @piwik_track + def read(self, request, slug): + """ Returns details of a book, identified by a slug. """ + + try: + return Book.objects.get(slug=slug) + except Book.DoesNotExist: + return rc.NOT_FOUND +class AnonymousBooksHandler(AnonymousBaseHandler): + """ Main handler for Book objects. + + Responsible for lists of Book objects + and fields used for representing Books. + + """ + allowed_methods = ('GET',) + model = Book + fields = ['href', 'title'] + + categories = set(['author', 'epoch', 'kind', 'genre']) + + @classmethod + def href(cls, book): + """ Returns an URI for a Book in the API. """ + return API_BASE + reverse("api_book", args=[book.slug]) + + @classmethod + def url(cls, book): + """ Returns Book's URL on the site. """ + + return WL_BASE + book.get_absolute_url() + + @piwik_track + def read(self, request, tags, top_level=False): + """ Lists all books with given tags. + + :param tags: filtering tags; should be a path of categories + and slugs, i.e.: authors/an-author/epoch/an-epoch/ + :param top_level: if True and a book is included in the results, + it's children are aren't. By default all books matching the tags + are returned. + """ + tags = read_tags(tags, allowed=self.categories) + if tags: + if top_level: + books = Book.tagged_top_level(tags) + return books if books else rc.NOT_FOUND + else: + books = Book.tagged.with_all(tags) + else: + books = Book.objects.all() + + if books.exists(): + return books + else: + return rc.NOT_FOUND + + def create(self, request, tags, top_level=False): + return 'aaa' + + @classmethod + def media(self, book): + """ Returns all media for a book. """ + + return book.media.all() + + +class BooksHandler(BaseHandler): + model = Book + fields = ('slug', 'title') + anonymous = AnonymousBooksHandler + + def create(self, request, tags, top_level=False): + if not request.user.has_perm('catalogue.add_book'): + return rc.FORBIDDEN + + data = json.loads(request.POST.get('data')) + form = BookImportForm(data) + if form.is_valid(): + form.save() + return rc.CREATED + else: + return rc.NOT_FOUND + +# add categorized tags fields for Book +def _tags_getter(category): + @classmethod + def get_tags(cls, book): + return book.tags.filter(category=category) + return get_tags +for plural, singular in category_singular.items(): + setattr(BooksHandler, plural, _tags_getter(singular)) + +# add fields for files in Book +def _file_getter(format): + field = "%s_file" % format + @classmethod + def get_file(cls, book): + f = getattr(book, field) + if f: + return MEDIA_BASE + f.url + else: + return '' + return get_file +for format in Book.file_types: + setattr(BooksHandler, format, _file_getter(format)) + + +class TagDetailHandler(BaseHandler): + """ Responsible for details of a single Tag object. """ + + fields = ['name', '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, e: + return rc.NOT_FOUND + + try: + return Tag.objects.get(category=category_sng, slug=slug) + except Tag.DoesNotExist: + return rc.NOT_FOUND + + +class TagsHandler(BaseHandler): + """ 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'] + + @piwik_track + def read(self, request, category): + """ Lists all tags in the category (eg. all themes). """ + + try: + category_sng = category_singular[category] + except KeyError, e: + return rc.NOT_FOUND + + tags = Tag.objects.filter(category=category_sng) + tags = [t for t in tags if t.get_count() > 0] + if tags: + return tags + else: + return rc.NOT_FOUND + + + @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]) + + +class FragmentDetailHandler(BaseHandler): + fields = ['book', 'anchor', 'text', 'url', 'themes'] + + @piwik_track + def read(self, request, slug, anchor): + """ Returns details of a fragment, identified by book slug and anchor. """ + + try: + return Fragment.objects.get(book__slug=slug, anchor=anchor) + except Fragment.DoesNotExist: + return rc.NOT_FOUND + + +class FragmentsHandler(BaseHandler): + """ Main handler for Fragments. + + Responsible for lists of Fragment objects + and fields used for representing Fragments. + + """ + model = Fragment + fields = ['book', 'anchor', 'href'] + allowed_methods = ('GET',) + + categories = set(['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/ + + """ + tags = read_tags(tags, allowed=self.categories) + fragments = Fragment.tagged.with_all(tags).select_related('book') + if fragments.exists(): + return fragments + else: + return rc.NOT_FOUND + + @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') + + + + +# Changes handlers + class CatalogueHandler(BaseHandler): @staticmethod @@ -21,12 +335,14 @@ class CatalogueHandler(BaseHandler): @staticmethod def until(t=None): """ Returns time suitable for use as upper time boundary for check. - - Defaults to 'five minutes ago' to avoid issues with time between - change stamp set and model save. + + Used to avoid issues with time between setting the change stamp + and actually saving the model in database. Cuts the microsecond part to avoid issues with DBs where time has more precision. + :param datetime t: manually sets the upper boundary + """ # set to five minutes ago, to avoid concurrency issues if t is None: @@ -36,16 +352,16 @@ class CatalogueHandler(BaseHandler): @staticmethod def book_dict(book, fields=None): - all_fields = ('url', 'title', 'description', + all_fields = ['url', 'title', 'description', 'gazeta_link', 'wiki_link', - 'xml', 'epub', 'txt', 'pdf', 'html', + ] + Book.file_types + [ 'mp3', 'ogg', 'daisy', 'parent', 'parent_number', 'tags', 'license', 'license_description', 'source_name', 'technical_editors', 'editors', 'author', 'sort_key', - ) + ] if fields: fields = (f for f in fields if f in all_fields) else: @@ -56,7 +372,7 @@ class CatalogueHandler(BaseHandler): obj = {} for field in fields: - if field in ('xml', 'epub', 'txt', 'pdf', 'html'): + if field in Book.file_types: f = getattr(book, field+'_file') if f: obj[field] = { @@ -83,6 +399,9 @@ class CatalogueHandler(BaseHandler): elif field == 'author': obj[field] = ", ".join(t.name for t in book.tags.filter(category='author')) + elif field == 'parent': + obj[field] = book.parent_id + elif field in ('license', 'license_description', 'source_name', 'technical_editors', 'editors'): f = extra_info.get(field) @@ -234,6 +553,7 @@ class CatalogueHandler(BaseHandler): class BookChangesHandler(CatalogueHandler): allowed_methods = ('GET',) + @piwik_track def read(self, request, since): return self.book_changes(request, since) @@ -241,6 +561,7 @@ class BookChangesHandler(CatalogueHandler): class TagChangesHandler(CatalogueHandler): allowed_methods = ('GET',) + @piwik_track def read(self, request, since): return self.tag_changes(request, since) @@ -248,5 +569,6 @@ class TagChangesHandler(CatalogueHandler): class ChangesHandler(CatalogueHandler): allowed_methods = ('GET',) + @piwik_track def read(self, request, since): return self.changes(request, since)