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