apps/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 picture.models import Picture
  17 from picture.forms import PictureImportForm
  18
  19 from stats.utils import piwik_track
  20
  21 from . import emitters # Register our emitters
  22
  23 API_BASE = WL_BASE = MEDIA_BASE = lazy(
  24     lambda: u'http://' + Site.objects.get_current().domain, unicode)()
  25
  26
  27 category_singular = {
  28     'authors': 'author',
  29     'kinds': 'kind',
  30     'genres': 'genre',
  31     'epochs': 'epoch',
  32     'themes': 'theme',
  33     'books': 'book',
  34 }
  35 category_plural = {}
  36 for k, v in category_singular.items():
  37     category_plural[v] = k
  38
  39 book_tag_categories = ['author', 'epoch', 'kind', 'genre']
  40
  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 not category 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
 141 class BookDetailHandler(BaseHandler, BookDetails):
 142     """ Main handler for Book objects.
 143
 144     Responsible for single Book details.
 145     """
 146     allowed_methods = ['GET']
 147     fields = ['title', 'parent', 'children'] + Book.formats + [
 148         'media', 'url', 'cover', 'cover_thumb'] + [
 149             category_plural[c] for c in book_tag_categories]
 150
 151     @piwik_track
 152     def read(self, request, book):
 153         """ Returns details of a book, identified by a slug and lang. """
 154         try:
 155             return Book.objects.get(slug=book)
 156         except Book.DoesNotExist:
 157             return rc.NOT_FOUND
 158
 159
 160 class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
 161     """ Main handler for Book objects.
 162
 163     Responsible for lists of Book objects.
 164     """
 165     allowed_methods = ('GET',)
 166     model = Book
 167     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
 168
 169     @classmethod
 170     def genres(cls, book):
 171         """ Returns all media for a book. """
 172         return book.tags.filter(category='genre')
 173
 174     @piwik_track
 175     def read(self, request, tags=None, top_level=False,
 176                 audiobooks=False, daisy=False, pk=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 = Book.objects.all()
 204
 205         if top_level:
 206             books = books.filter(parent=None)
 207         if audiobooks:
 208             books = books.filter(media__type='mp3').distinct()
 209         if daisy:
 210             books = books.filter(media__type='daisy').distinct()
 211
 212         if books.exists():
 213             return books
 214         else:
 215             return rc.NOT_FOUND
 216
 217     def create(self, request, *args, **kwargs):
 218         return rc.FORBIDDEN
 219
 220
 221 class BooksHandler(BookDetailHandler):
 222     allowed_methods = ('GET', 'POST')
 223     model = Book
 224     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
 225     anonymous = AnonymousBooksHandler
 226
 227     def create(self, request, *args, **kwargs):
 228         if not request.user.has_perm('catalogue.add_book'):
 229             return rc.FORBIDDEN
 230
 231         data = json.loads(request.POST.get('data'))
 232         form = BookImportForm(data)
 233         if form.is_valid():
 234             form.save()
 235             return rc.CREATED
 236         else:
 237             return rc.NOT_FOUND
 238
 239
 240 class EBooksHandler(AnonymousBooksHandler):
 241     fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats)
 242
 243
 244 # add categorized tags fields for Book
 245 def _tags_getter(category):
 246     @classmethod
 247     def get_tags(cls, book):
 248         return book.tags.filter(category=category)
 249     return get_tags
 250 def _tag_getter(category):
 251     @classmethod
 252     def get_tag(cls, book):
 253         return ', '.join(tag.name for tag in book.tags.filter(category=category))
 254     return get_tag
 255 for plural, singular in category_singular.items():
 256     setattr(BookDetails, plural, _tags_getter(singular))
 257     setattr(BookDetails, singular, _tag_getter(singular))
 258
 259 # add fields for files in Book
 260 def _file_getter(format):
 261     field = "%s_file" % format
 262     @classmethod
 263     def get_file(cls, book):
 264         f = getattr(book, field)
 265         if f:
 266             return MEDIA_BASE + f.url
 267         else:
 268             return ''
 269     return get_file
 270 for format in Book.formats:
 271     setattr(BookDetails, format, _file_getter(format))
 272
 273
 274 class CollectionDetails(object):
 275     """Custom Collection fields."""
 276
 277     @classmethod
 278     def href(cls, collection):
 279         """ Returns URI in the API for the collection. """
 280
 281         return API_BASE + reverse("api_collection", args=[collection.slug])
 282
 283     @classmethod
 284     def url(cls, collection):
 285         """ Returns URL on the site. """
 286
 287         return WL_BASE + collection.get_absolute_url()
 288
 289     @classmethod
 290     def books(cls, collection):
 291         return Book.objects.filter(collection.get_query())
 292
 293
 294
 295 class CollectionDetailHandler(BaseHandler, CollectionDetails):
 296     allowed_methods = ('GET',)
 297     fields = ['url', 'title', 'description', 'books']
 298
 299     @piwik_track
 300     def read(self, request, slug):
 301         """ Returns details of a collection, identified by slug. """
 302         try:
 303             return Collection.objects.get(slug=slug)
 304         except Collection.DoesNotExist:
 305             return rc.NOT_FOUND
 306
 307
 308 class CollectionsHandler(BaseHandler, CollectionDetails):
 309     allowed_methods = ('GET',)
 310     model = Collection
 311     fields = ['url', 'href', 'title']
 312
 313     @piwik_track
 314     def read(self, request):
 315         """ Returns all collections. """
 316         return Collection.objects.all()
 317
 318
 319 class TagDetails(object):
 320     """Custom Tag fields."""
 321
 322     @classmethod
 323     def href(cls, tag):
 324         """ Returns URI in the API for the tag. """
 325
 326         return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
 327
 328     @classmethod
 329     def url(cls, tag):
 330         """ Returns URL on the site. """
 331
 332         return WL_BASE + tag.get_absolute_url()
 333
 334
 335 class TagDetailHandler(BaseHandler, TagDetails):
 336     """ Responsible for details of a single Tag object. """
 337
 338     fields = ['name', 'url', 'sort_key', 'description']
 339
 340     @piwik_track
 341     def read(self, request, category, slug):
 342         """ Returns details of a tag, identified by category and slug. """
 343
 344         try:
 345             category_sng = category_singular[category]
 346         except KeyError, e:
 347             return rc.NOT_FOUND
 348
 349         try:
 350             return Tag.objects.get(category=category_sng, slug=slug)
 351         except Tag.DoesNotExist:
 352             return rc.NOT_FOUND
 353
 354
 355 class TagsHandler(BaseHandler, TagDetails):
 356     """ Main handler for Tag objects.
 357
 358     Responsible for lists of Tag objects
 359     and fields used for representing Tags.
 360
 361     """
 362     allowed_methods = ('GET',)
 363     model = Tag
 364     fields = ['name', 'href', 'url']
 365
 366     @piwik_track
 367     def read(self, request, category=None, pk=None):
 368         """ Lists all tags in the category (eg. all themes). """
 369         if pk is not None:
 370             try:
 371                 return Tag.objects.exclude(category='set').get(pk=pk)
 372             except Book.DoesNotExist:
 373                 return rc.NOT_FOUND
 374
 375         try:
 376             category_sng = category_singular[category]
 377         except KeyError, e:
 378             return rc.NOT_FOUND
 379
 380         tags = Tag.objects.filter(category=category_sng).exclude(items=None)
 381         if tags.exists():
 382             return tags
 383         else:
 384             return rc.NOT_FOUND
 385
 386
 387 class FragmentDetails(object):
 388     """Custom Fragment fields."""
 389
 390     @classmethod
 391     def href(cls, fragment):
 392         """ Returns URI in the API for the fragment. """
 393
 394         return API_BASE + reverse("api_fragment",
 395             args=[fragment.book.slug, fragment.anchor])
 396
 397     @classmethod
 398     def url(cls, fragment):
 399         """ Returns URL on the site for the fragment. """
 400
 401         return WL_BASE + fragment.get_absolute_url()
 402
 403     @classmethod
 404     def themes(cls, fragment):
 405         """ Returns a list of theme tags for the fragment. """
 406
 407         return fragment.tags.filter(category='theme')
 408
 409
 410 class FragmentDetailHandler(BaseHandler, FragmentDetails):
 411     fields = ['book', 'anchor', 'text', 'url', 'themes']
 412
 413     @piwik_track
 414     def read(self, request, book, anchor):
 415         """ Returns details of a fragment, identified by book slug and anchor. """
 416         try:
 417             return Fragment.objects.get(book__slug=book, anchor=anchor)
 418         except Fragment.DoesNotExist:
 419             return rc.NOT_FOUND
 420
 421
 422 class FragmentsHandler(BaseHandler, FragmentDetails):
 423     """ Main handler for Fragments.
 424
 425     Responsible for lists of Fragment objects
 426     and fields used for representing Fragments.
 427
 428     """
 429     model = Fragment
 430     fields = ['book', 'url', 'anchor', 'href']
 431     allowed_methods = ('GET',)
 432
 433     categories = set(['author', 'epoch', 'kind', 'genre', 'book', 'theme'])
 434
 435     @piwik_track
 436     def read(self, request, tags):
 437         """ Lists all fragments with given book, tags, themes.
 438
 439         :param tags: should be a path of categories and slugs, i.e.:
 440              books/book-slug/authors/an-author/themes/a-theme/
 441
 442         """
 443         try:
 444             tags, ancestors = read_tags(tags, allowed=self.categories)
 445         except ValueError:
 446             return rc.NOT_FOUND
 447         fragments = Fragment.tagged.with_all(tags).select_related('book')
 448         if fragments.exists():
 449             return fragments
 450         else:
 451             return rc.NOT_FOUND
 452
 453
 454 class PictureHandler(BaseHandler):
 455     model = Picture
 456     fields = ('slug', 'title')
 457     allowed_methods = ('POST',)
 458
 459     def create(self, request):
 460         if not request.user.has_perm('picture.add_picture'):
 461             return rc.FORBIDDEN
 462
 463         data = json.loads(request.POST.get('data'))
 464         form = PictureImportForm(data)
 465         if form.is_valid():
 466             form.save()
 467             return rc.CREATED
 468         else:
 469             return rc.NOT_FOUND