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