option to turn off ssify just for api + some optimizations
[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.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 def read_tags(tags, allowed):
43     """ Reads a path of filtering tags.
44
45     :param str tags: a path of category and slug pairs, like: authors/an-author/...
46     :returns: list of Tag objects
47     :raises: ValueError when tags can't be found
48     """
49     if not tags:
50         return [], []
51
52     tags = tags.strip('/').split('/')
53     real_tags = []
54     books = []
55     while tags:
56         category = tags.pop(0)
57         slug = tags.pop(0)
58
59         try:
60             category = category_singular[category]
61         except KeyError:
62             raise ValueError('Unknown category.')
63
64         if category not in allowed:
65             raise ValueError('Category not allowed.')
66
67         if category == 'book':
68             try:
69                 books.append(Book.objects.get(slug=slug))
70             except Book.DoesNotExist:
71                 raise ValueError('Unknown book.')
72
73         try:
74             real_tags.append(Tag.objects.get(category=category, slug=slug))
75         except Tag.DoesNotExist:
76             raise ValueError('Tag not found')
77     return real_tags, books
78
79
80 # RESTful handlers
81
82
83 class BookMediaHandler(BaseHandler):
84     """ Responsible for representing media in Books. """
85
86     model = BookMedia
87     fields = ['name', 'type', 'url', 'artist', 'director']
88
89     @classmethod
90     def url(cls, media):
91         """ Link to media on site. """
92
93         return MEDIA_BASE + media.file.url
94
95     @classmethod
96     def artist(cls, media):
97         return media.extra_info.get('artist_name', '')
98
99     @classmethod
100     def director(cls, media):
101         return media.extra_info.get('director_name', '')
102
103
104 class BookDetails(object):
105     """Custom fields used for representing Books."""
106
107     @classmethod
108     def href(cls, book):
109         """ Returns an URI for a Book in the API. """
110         return API_BASE + reverse("api_book", args=[book.slug])
111
112     @classmethod
113     def url(cls, book):
114         """ Returns Book's URL on the site. """
115
116         return WL_BASE + book.get_absolute_url()
117
118     @classmethod
119     def children(cls, book):
120         """ Returns all children for a book. """
121
122         return book.children.all()
123
124     @classmethod
125     def media(cls, book):
126         """ Returns all media for a book. """
127         return book.media.all()
128
129     @classmethod
130     def cover(cls, book):
131         return MEDIA_BASE + book.cover.url if book.cover else ''
132
133     @classmethod
134     def cover_thumb(cls, book):
135         return MEDIA_BASE + default.backend.get_thumbnail(
136                     book.cover, "139x193").url if book.cover else ''
137
138
139 class BookDetailHandler(BaseHandler, BookDetails):
140     """ Main handler for Book objects.
141
142     Responsible for single Book details.
143     """
144     allowed_methods = ['GET']
145     fields = ['title', 'parent', 'children'] + Book.formats + [
146         'media', 'url', 'cover', 'cover_thumb'] + [
147             category_plural[c] for c in book_tag_categories]
148
149     @piwik_track
150     def read(self, request, book):
151         """ Returns details of a book, identified by a slug and lang. """
152         try:
153             return Book.objects.get(slug=book)
154         except Book.DoesNotExist:
155             return rc.NOT_FOUND
156
157
158 class AnonymousBooksHandler(AnonymousBaseHandler, BookDetails):
159     """ Main handler for Book objects.
160
161     Responsible for lists of Book objects.
162     """
163     allowed_methods = ('GET',)
164     model = Book
165     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
166
167     @classmethod
168     def genres(cls, book):
169         """ Returns all media for a book. """
170         return book.tags.filter(category='genre')
171
172     @piwik_track
173     def read(self, request, tags=None, top_level=False, audiobooks=False, daisy=False, pk=None):
174         """ Lists all books with given tags.
175
176         :param tags: filtering tags; should be a path of categories
177              and slugs, i.e.: authors/an-author/epoch/an-epoch/
178         :param top_level: if True and a book is included in the results,
179              it's children are aren't. By default all books matching the tags
180              are returned.
181         """
182         if pk is not None:
183             try:
184                 return Book.objects.get(pk=pk)
185             except Book.DoesNotExist:
186                 return rc.NOT_FOUND
187
188         try:
189             tags, _ancestors = read_tags(tags, allowed=book_tag_categories)
190         except ValueError:
191             return rc.NOT_FOUND
192
193         if tags:
194             if top_level:
195                 books = Book.tagged_top_level(tags)
196                 return books if books else rc.NOT_FOUND
197             else:
198                 books = Book.tagged.with_all(tags)
199         else:
200             books = Book.objects.all()
201
202         if top_level:
203             books = books.filter(parent=None)
204         if audiobooks:
205             books = books.filter(media__type='mp3').distinct()
206         if daisy:
207             books = books.filter(media__type='daisy').distinct()
208
209         books = books.only('slug', 'title', 'cover')
210
211         if books:
212             return books
213         else:
214             return rc.NOT_FOUND
215
216     def create(self, request, *args, **kwargs):
217         return rc.FORBIDDEN
218
219
220 class BooksHandler(BookDetailHandler):
221     allowed_methods = ('GET', 'POST')
222     model = Book
223     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
224     anonymous = AnonymousBooksHandler
225
226     def create(self, request, *args, **kwargs):
227         if not request.user.has_perm('catalogue.add_book'):
228             return rc.FORBIDDEN
229
230         data = json.loads(request.POST.get('data'))
231         form = BookImportForm(data)
232         if form.is_valid():
233             form.save()
234             return rc.CREATED
235         else:
236             return rc.NOT_FOUND
237
238
239 class EBooksHandler(AnonymousBooksHandler):
240     fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats)
241
242
243 # add categorized tags fields for Book
244 def _tags_getter(category):
245     @classmethod
246     def get_tags(cls, book):
247         return book.tags.filter(category=category)
248     return get_tags
249
250
251 def _tag_getter(category):
252     @classmethod
253     def get_tag(cls, book):
254         return ', '.join(book.tags.filter(category=category).values_list('name', flat=True))
255     return get_tag
256
257
258 def add_tag_getters():
259     for plural, singular in category_singular.items():
260         setattr(BookDetails, plural, _tags_getter(singular))
261         setattr(BookDetails, singular, _tag_getter(singular))
262
263 add_tag_getters()
264
265
266 # add fields for files in Book
267 def _file_getter(book_format):
268     field = "%s_file" % book_format
269
270     @classmethod
271     def get_file(cls, book):
272         f = getattr(book, field)
273         if f:
274             return MEDIA_BASE + f.url
275         else:
276             return ''
277     return get_file
278
279
280 def add_file_getters():
281     for book_format in Book.formats:
282         setattr(BookDetails, book_format, _file_getter(book_format))
283
284 add_file_getters()
285
286
287 class CollectionDetails(object):
288     """Custom Collection fields."""
289
290     @classmethod
291     def href(cls, collection):
292         """ Returns URI in the API for the collection. """
293
294         return API_BASE + reverse("api_collection", args=[collection.slug])
295
296     @classmethod
297     def url(cls, collection):
298         """ Returns URL on the site. """
299
300         return WL_BASE + collection.get_absolute_url()
301
302     @classmethod
303     def books(cls, collection):
304         return Book.objects.filter(collection.get_query())
305
306
307 class CollectionDetailHandler(BaseHandler, CollectionDetails):
308     allowed_methods = ('GET',)
309     fields = ['url', 'title', 'description', 'books']
310
311     @piwik_track
312     def read(self, request, slug):
313         """ Returns details of a collection, identified by slug. """
314         try:
315             return Collection.objects.get(slug=slug)
316         except Collection.DoesNotExist:
317             return rc.NOT_FOUND
318
319
320 class CollectionsHandler(BaseHandler, CollectionDetails):
321     allowed_methods = ('GET',)
322     model = Collection
323     fields = ['url', 'href', 'title']
324
325     @piwik_track
326     def read(self, request):
327         """ Returns all collections. """
328         return Collection.objects.all()
329
330
331 class TagDetails(object):
332     """Custom Tag fields."""
333
334     @classmethod
335     def href(cls, tag):
336         """ Returns URI in the API for the tag. """
337
338         return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
339
340     @classmethod
341     def url(cls, tag):
342         """ Returns URL on the site. """
343
344         return WL_BASE + tag.get_absolute_url()
345
346
347 class TagDetailHandler(BaseHandler, TagDetails):
348     """ Responsible for details of a single Tag object. """
349
350     fields = ['name', 'url', 'sort_key', 'description']
351
352     @piwik_track
353     def read(self, request, category, slug):
354         """ Returns details of a tag, identified by category and slug. """
355
356         try:
357             category_sng = category_singular[category]
358         except KeyError:
359             return rc.NOT_FOUND
360
361         try:
362             return Tag.objects.get(category=category_sng, slug=slug)
363         except Tag.DoesNotExist:
364             return rc.NOT_FOUND
365
366
367 class TagsHandler(BaseHandler, TagDetails):
368     """ Main handler for Tag objects.
369
370     Responsible for lists of Tag objects
371     and fields used for representing Tags.
372
373     """
374     allowed_methods = ('GET',)
375     model = Tag
376     fields = ['name', 'href', 'url']
377
378     @piwik_track
379     def read(self, request, category=None, pk=None):
380         """ Lists all tags in the category (eg. all themes). """
381         if pk is not None:
382             try:
383                 return Tag.objects.exclude(category='set').get(pk=pk)
384             except Book.DoesNotExist:
385                 return rc.NOT_FOUND
386
387         try:
388             category_sng = category_singular[category]
389         except KeyError:
390             return rc.NOT_FOUND
391
392         tags = Tag.objects.filter(category=category_sng).exclude(items=None)
393         if tags.exists():
394             return tags
395         else:
396             return rc.NOT_FOUND
397
398
399 class FragmentDetails(object):
400     """Custom Fragment fields."""
401
402     @classmethod
403     def href(cls, fragment):
404         """ Returns URI in the API for the fragment. """
405
406         return API_BASE + reverse("api_fragment", args=[fragment.book.slug, fragment.anchor])
407
408     @classmethod
409     def url(cls, fragment):
410         """ Returns URL on the site for the fragment. """
411
412         return WL_BASE + fragment.get_absolute_url()
413
414     @classmethod
415     def themes(cls, fragment):
416         """ Returns a list of theme tags for the fragment. """
417
418         return fragment.tags.filter(category='theme')
419
420
421 class FragmentDetailHandler(BaseHandler, FragmentDetails):
422     fields = ['book', 'anchor', 'text', 'url', 'themes']
423
424     @piwik_track
425     def read(self, request, book, anchor):
426         """ Returns details of a fragment, identified by book slug and anchor. """
427         try:
428             return Fragment.objects.get(book__slug=book, anchor=anchor)
429         except Fragment.DoesNotExist:
430             return rc.NOT_FOUND
431
432
433 class FragmentsHandler(BaseHandler, FragmentDetails):
434     """ Main handler for Fragments.
435
436     Responsible for lists of Fragment objects
437     and fields used for representing Fragments.
438
439     """
440     model = Fragment
441     fields = ['book', 'url', 'anchor', 'href']
442     allowed_methods = ('GET',)
443
444     categories = {'author', 'epoch', 'kind', 'genre', 'book', 'theme'}
445
446     @piwik_track
447     def read(self, request, tags):
448         """ Lists all fragments with given book, tags, themes.
449
450         :param tags: should be a path of categories and slugs, i.e.:
451              books/book-slug/authors/an-author/themes/a-theme/
452
453         """
454         try:
455             tags, ancestors = read_tags(tags, allowed=self.categories)
456         except ValueError:
457             return rc.NOT_FOUND
458         fragments = Fragment.tagged.with_all(tags).select_related('book')
459         if fragments.exists():
460             return fragments
461         else:
462             return rc.NOT_FOUND
463
464
465 class PictureHandler(BaseHandler):
466     model = Picture
467     fields = ('slug', 'title')
468     allowed_methods = ('POST',)
469
470     def create(self, request):
471         if not request.user.has_perm('picture.add_picture'):
472             return rc.FORBIDDEN
473
474         data = json.loads(request.POST.get('data'))
475         form = PictureImportForm(data)
476         if form.is_valid():
477             form.save()
478             return rc.CREATED
479         else:
480             return rc.NOT_FOUND