src/api/handlers.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
   3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   4 #
   5 import json
   6
   7 from django.contrib.sites.models import Site
   8 from django.core.urlresolvers import reverse
   9 from django.utils.functional import lazy
  10 from piston.handler import AnonymousBaseHandler, BaseHandler
  11 from piston.utils import rc
  12 from sorl.thumbnail import default
  13
  14 from catalogue.forms import BookImportForm
  15 from catalogue.models import Book, Tag, BookMedia, Fragment, Collection
  16 from catalogue.models.tag import prefetch_relations
  17 from picture.models import Picture
  18 from picture.forms import PictureImportForm
  19
  20 from stats.utils import piwik_track
  21
  22 from . import emitters  # Register our emitters
  23
  24 API_BASE = WL_BASE = MEDIA_BASE = lazy(
  25     lambda: u'http://' + Site.objects.get_current().domain, unicode)()
  26
  27
  28 category_singular = {
  29     'authors': 'author',
  30     'kinds': 'kind',
  31     'genres': 'genre',
  32     'epochs': 'epoch',
  33     'themes': 'theme',
  34     'books': 'book',
  35 }
  36 category_plural = {}
  37 for k, v in category_singular.items():
  38     category_plural[v] = k
  39
  40 book_tag_categories = ['author', 'epoch', 'kind', 'genre']
  41
  42
  43 def read_tags(tags, allowed):
  44     """ Reads a path of filtering tags.
  45
  46     :param str tags: a path of category and slug pairs, like: authors/an-author/...
  47     :returns: list of Tag objects
  48     :raises: ValueError when tags can't be found
  49     """
  50     if not tags:
  51         return [], []
  52
  53     tags = tags.strip('/').split('/')
  54     real_tags = []
  55     books = []
  56     while tags:
  57         category = tags.pop(0)
  58         slug = tags.pop(0)
  59
  60         try:
  61             category = category_singular[category]
  62         except KeyError:
  63             raise ValueError('Unknown category.')
  64
  65         if category not in allowed:
  66             raise ValueError('Category not allowed.')
  67
  68         if category == 'book':
  69             try:
  70                 books.append(Book.objects.get(slug=slug))
  71             except Book.DoesNotExist:
  72                 raise ValueError('Unknown book.')
  73
  74         try:
  75             real_tags.append(Tag.objects.get(category=category, slug=slug))
  76         except Tag.DoesNotExist:
  77             raise ValueError('Tag not found')
  78     return real_tags, books
  79
  80
  81 # RESTful handlers
  82
  83
  84 class BookMediaHandler(BaseHandler):
  85     """ Responsible for representing media in Books. """
  86
  87     model = BookMedia
  88     fields = ['name', 'type', 'url', 'artist', 'director']
  89
  90     @classmethod
  91     def url(cls, media):
  92         """ Link to media on site. """
  93
  94         return MEDIA_BASE + media.file.url
  95
  96     @classmethod
  97     def artist(cls, media):
  98         return media.extra_info.get('artist_name', '')
  99
 100     @classmethod
 101     def director(cls, media):
 102         return media.extra_info.get('director_name', '')
 103
 104
 105 class BookDetails(object):
 106     """Custom fields used for representing Books."""
 107
 108     @classmethod
 109     def href(cls, book):
 110         """ Returns an URI for a Book in the API. """
 111         return API_BASE + reverse("api_book", args=[book.slug])
 112
 113     @classmethod
 114     def url(cls, book):
 115         """ Returns Book's URL on the site. """
 116
 117         return WL_BASE + book.get_absolute_url()
 118
 119     @classmethod
 120     def children(cls, book):
 121         """ Returns all children for a book. """
 122
 123         return book.children.all()
 124
 125     @classmethod
 126     def media(cls, book):
 127         """ Returns all media for a book. """
 128         return book.media.all()
 129
 130     @classmethod
 131     def cover(cls, book):
 132         return MEDIA_BASE + book.cover.url if book.cover else ''
 133
 134     @classmethod
 135     def cover_thumb(cls, book):
 136         return MEDIA_BASE + default.backend.get_thumbnail(
 137                     book.cover, "139x193").url if book.cover else ''
 138
 139
 140 class BookDetailHandler(BaseHandler, BookDetails):
 141     """ Main handler for Book objects.
 142
 143     Responsible for single Book details.
 144     """
 145     allowed_methods = ['GET']
 146     fields = ['title', 'parent', 'children'] + Book.formats + [
 147         'media', 'url', 'cover', 'cover_thumb'] + [
 148             category_plural[c] for c in book_tag_categories]
 149
 150     @piwik_track
 151     def read(self, request, book):
 152         """ Returns details of a book, identified by a slug and lang. """
 153         try:
 154             return Book.objects.get(slug=book)
 155         except Book.DoesNotExist:
 156             return rc.NOT_FOUND
 157
 158
 159 class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
 160     """ Main handler for Book objects.
 161
 162     Responsible for lists of Book objects.
 163     """
 164     allowed_methods = ('GET',)
 165     model = Book
 166     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb', 'slug']
 167
 168     @classmethod
 169     def genres(cls, book):
 170         """ Returns all media for a book. """
 171         return book.tags.filter(category='genre')
 172
 173     @piwik_track
 174     def read(self, request, tags=None, top_level=False, audiobooks=False, daisy=False, pk=None,
 175              recommended=False, newest=False, books=None,
 176              after=None, before=None, count=None):
 177         """ Lists all books with given tags.
 178
 179         :param tags: filtering tags; should be a path of categories
 180              and slugs, i.e.: authors/an-author/epoch/an-epoch/
 181         :param top_level: if True and a book is included in the results,
 182              it's children are aren't. By default all books matching the tags
 183              are returned.
 184         """
 185         if pk is not None:
 186             try:
 187                 return Book.objects.get(pk=pk)
 188             except Book.DoesNotExist:
 189                 return rc.NOT_FOUND
 190
 191         try:
 192             tags, _ancestors = read_tags(tags, allowed=book_tag_categories)
 193         except ValueError:
 194             return rc.NOT_FOUND
 195
 196         if tags:
 197             if top_level:
 198                 books = Book.tagged_top_level(tags)
 199                 return books if books else rc.NOT_FOUND
 200             else:
 201                 books = Book.tagged.with_all(tags)
 202         else:
 203             books = books if books is not None else Book.objects.all()
 204         books = books.order_by('slug')
 205
 206         if top_level:
 207             books = books.filter(parent=None)
 208         if audiobooks:
 209             books = books.filter(media__type='mp3').distinct()
 210         if daisy:
 211             books = books.filter(media__type='daisy').distinct()
 212         if recommended:
 213             books = books.filter(recommended=True)
 214         if newest:
 215             books = books.order_by('-created_at')
 216
 217         if after:
 218             books = books.filter(slug__gt=after)
 219         if before:
 220             books = books.filter(slug__lt=before)
 221
 222         books = books.only('slug', 'title', 'cover', 'cover_thumb')
 223         for category in book_tag_categories:
 224             books = prefetch_relations(books, category)
 225
 226         if count:
 227             if before:
 228                 books = list(reversed(books.order_by('-slug')[:count]))
 229             else:
 230                 books = books[:count]
 231
 232         if books:
 233             return books
 234         else:
 235             return rc.NOT_FOUND
 236
 237     def create(self, request, *args, **kwargs):
 238         return rc.FORBIDDEN
 239
 240
 241 class BooksHandler(BookDetailHandler):
 242     allowed_methods = ('GET', 'POST')
 243     model = Book
 244     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb', 'slug']
 245     anonymous = AnonymousBooksHandler
 246
 247     def create(self, request, *args, **kwargs):
 248         if not request.user.has_perm('catalogue.add_book'):
 249             return rc.FORBIDDEN
 250
 251         data = json.loads(request.POST.get('data'))
 252         form = BookImportForm(data)
 253         if form.is_valid():
 254             form.save()
 255             return rc.CREATED
 256         else:
 257             return rc.NOT_FOUND
 258
 259
 260 class EBooksHandler(AnonymousBooksHandler):
 261     fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats) + ('slug',)
 262
 263
 264 class FilterBooksHandler(AnonymousBooksHandler):
 265     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb', 'slug']
 266
 267     def read(self, request, title_part=None, author_part=None, is_lektura=None, is_audiobook=None,
 268              after=None, before=None, count=None):
 269         if count is None:
 270             count = 50
 271         if is_lektura in ('true', 'false'):
 272             is_lektura = is_lektura == 'true'
 273         else:
 274             is_lektura = None
 275         if is_audiobook in ('true', 'false'):
 276             is_audiobook = is_audiobook == 'true'
 277         books = Book.objects.distinct()
 278         if title_part:
 279             books = books.filter(title__icontains=title_part)
 280         if author_part is not None:
 281             books = books.filter(cached_author__icontains=author_part)
 282         if is_lektura is not None:
 283             books = books.filter(has_audience=is_lektura)
 284         if is_audiobook is not None:
 285             if is_audiobook:
 286                 books = books.filter(media__type='mp3')
 287             else:
 288                 books = books.exclude(media__type='mp3')
 289         return super(FilterBooksHandler, self).read(request, books=books, after=after, before=before, count=count)
 290
 291
 292 # add categorized tags fields for Book
 293 def _tags_getter(category):
 294     @classmethod
 295     def get_tags(cls, book):
 296         return book.tags.filter(category=category)
 297     return get_tags
 298
 299
 300 def _tag_getter(category):
 301     @classmethod
 302     def get_tag(cls, book):
 303         return book.tag_unicode(category)
 304     return get_tag
 305
 306
 307 def add_tag_getters():
 308     for plural, singular in category_singular.items():
 309         setattr(BookDetails, plural, _tags_getter(singular))
 310         setattr(BookDetails, singular, _tag_getter(singular))
 311
 312 add_tag_getters()
 313
 314
 315 # add fields for files in Book
 316 def _file_getter(book_format):
 317     field = "%s_file" % book_format
 318
 319     @classmethod
 320     def get_file(cls, book):
 321         f = getattr(book, field)
 322         if f:
 323             return MEDIA_BASE + f.url
 324         else:
 325             return ''
 326     return get_file
 327
 328
 329 def add_file_getters():
 330     for book_format in Book.formats:
 331         setattr(BookDetails, book_format, _file_getter(book_format))
 332
 333 add_file_getters()
 334
 335
 336 class CollectionDetails(object):
 337     """Custom Collection fields."""
 338
 339     @classmethod
 340     def href(cls, collection):
 341         """ Returns URI in the API for the collection. """
 342
 343         return API_BASE + reverse("api_collection", args=[collection.slug])
 344
 345     @classmethod
 346     def url(cls, collection):
 347         """ Returns URL on the site. """
 348
 349         return WL_BASE + collection.get_absolute_url()
 350
 351     @classmethod
 352     def books(cls, collection):
 353         return Book.objects.filter(collection.get_query())
 354
 355
 356 class CollectionDetailHandler(BaseHandler, CollectionDetails):
 357     allowed_methods = ('GET',)
 358     fields = ['url', 'title', 'description', 'books']
 359
 360     @piwik_track
 361     def read(self, request, slug):
 362         """ Returns details of a collection, identified by slug. """
 363         try:
 364             return Collection.objects.get(slug=slug)
 365         except Collection.DoesNotExist:
 366             return rc.NOT_FOUND
 367
 368
 369 class CollectionsHandler(BaseHandler, CollectionDetails):
 370     allowed_methods = ('GET',)
 371     model = Collection
 372     fields = ['url', 'href', 'title']
 373
 374     @piwik_track
 375     def read(self, request):
 376         """ Returns all collections. """
 377         return Collection.objects.all()
 378
 379
 380 class TagDetails(object):
 381     """Custom Tag fields."""
 382
 383     @classmethod
 384     def href(cls, tag):
 385         """ Returns URI in the API for the tag. """
 386
 387         return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
 388
 389     @classmethod
 390     def url(cls, tag):
 391         """ Returns URL on the site. """
 392
 393         return WL_BASE + tag.get_absolute_url()
 394
 395
 396 class TagDetailHandler(BaseHandler, TagDetails):
 397     """ Responsible for details of a single Tag object. """
 398
 399     fields = ['name', 'url', 'sort_key', 'description']
 400
 401     @piwik_track
 402     def read(self, request, category, slug):
 403         """ Returns details of a tag, identified by category and slug. """
 404
 405         try:
 406             category_sng = category_singular[category]
 407         except KeyError:
 408             return rc.NOT_FOUND
 409
 410         try:
 411             return Tag.objects.get(category=category_sng, slug=slug)
 412         except Tag.DoesNotExist:
 413             return rc.NOT_FOUND
 414
 415
 416 class TagsHandler(BaseHandler, TagDetails):
 417     """ Main handler for Tag objects.
 418
 419     Responsible for lists of Tag objects
 420     and fields used for representing Tags.
 421
 422     """
 423     allowed_methods = ('GET',)
 424     model = Tag
 425     fields = ['name', 'href', 'url']
 426
 427     @piwik_track
 428     def read(self, request, category=None, pk=None):
 429         """ Lists all tags in the category (eg. all themes). """
 430         if pk is not None:
 431             try:
 432                 return Tag.objects.exclude(category='set').get(pk=pk)
 433             except Book.DoesNotExist:
 434                 return rc.NOT_FOUND
 435
 436         try:
 437             category_sng = category_singular[category]
 438         except KeyError:
 439             return rc.NOT_FOUND
 440
 441         tags = Tag.objects.filter(category=category_sng).exclude(items=None)
 442         if tags.exists():
 443             return tags
 444         else:
 445             return rc.NOT_FOUND
 446
 447
 448 class FragmentDetails(object):
 449     """Custom Fragment fields."""
 450
 451     @classmethod
 452     def href(cls, fragment):
 453         """ Returns URI in the API for the fragment. """
 454
 455         return API_BASE + reverse("api_fragment", args=[fragment.book.slug, fragment.anchor])
 456
 457     @classmethod
 458     def url(cls, fragment):
 459         """ Returns URL on the site for the fragment. """
 460
 461         return WL_BASE + fragment.get_absolute_url()
 462
 463     @classmethod
 464     def themes(cls, fragment):
 465         """ Returns a list of theme tags for the fragment. """
 466
 467         return fragment.tags.filter(category='theme')
 468
 469
 470 class FragmentDetailHandler(BaseHandler, FragmentDetails):
 471     fields = ['book', 'anchor', 'text', 'url', 'themes']
 472
 473     @piwik_track
 474     def read(self, request, book, anchor):
 475         """ Returns details of a fragment, identified by book slug and anchor. """
 476         try:
 477             return Fragment.objects.get(book__slug=book, anchor=anchor)
 478         except Fragment.DoesNotExist:
 479             return rc.NOT_FOUND
 480
 481
 482 class FragmentsHandler(BaseHandler, FragmentDetails):
 483     """ Main handler for Fragments.
 484
 485     Responsible for lists of Fragment objects
 486     and fields used for representing Fragments.
 487
 488     """
 489     model = Fragment
 490     fields = ['book', 'url', 'anchor', 'href']
 491     allowed_methods = ('GET',)
 492
 493     categories = {'author', 'epoch', 'kind', 'genre', 'book', 'theme'}
 494
 495     @piwik_track
 496     def read(self, request, tags):
 497         """ Lists all fragments with given book, tags, themes.
 498
 499         :param tags: should be a path of categories and slugs, i.e.:
 500              books/book-slug/authors/an-author/themes/a-theme/
 501
 502         """
 503         try:
 504             tags, ancestors = read_tags(tags, allowed=self.categories)
 505         except ValueError:
 506             return rc.NOT_FOUND
 507         fragments = Fragment.tagged.with_all(tags).select_related('book')
 508         if fragments.exists():
 509             return fragments
 510         else:
 511             return rc.NOT_FOUND
 512
 513
 514 class PictureHandler(BaseHandler):
 515     model = Picture
 516     fields = ('slug', 'title')
 517     allowed_methods = ('POST',)
 518
 519     def create(self, request):
 520         if not request.user.has_perm('picture.add_picture'):
 521             return rc.FORBIDDEN
 522
 523         data = json.loads(request.POST.get('data'))
 524         form = PictureImportForm(data)
 525         if form.is_valid():
 526             form.save()
 527             return rc.CREATED
 528         else:
 529             return rc.NOT_FOUND