cover_thumb, genre, epoch, kind in api/books.
[wolnelektury.git] / 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 from datetime import datetime, timedelta
6 import json
7 from urlparse import urljoin
8
9 from django.conf import settings
10 from django.contrib.sites.models import Site
11 from django.core.cache import get_cache
12 from django.core.urlresolvers import reverse
13 from piston.handler import AnonymousBaseHandler, BaseHandler
14 from piston.utils import rc
15 from sorl.thumbnail import default
16
17 from api.helpers import timestamp
18 from api.models import Deleted
19 from catalogue.forms import BookImportForm
20 from catalogue.models import Book, Tag, BookMedia, Fragment, Collection
21 from picture.models import Picture
22 from picture.forms import PictureImportForm
23
24 from stats.utils import piwik_track
25
26 API_BASE = WL_BASE = MEDIA_BASE = 'http://' + Site.objects.get_current().domain
27
28
29 category_singular = {
30     'authors': 'author',
31     'kinds': 'kind',
32     'genres': 'genre',
33     'epochs': 'epoch',
34     'themes': 'theme',
35     'books': 'book',
36 }
37 category_plural={}
38 for k, v in category_singular.items():
39     category_plural[v] = k
40
41 book_tag_categories = ['author', 'epoch', 'kind', 'genre']
42
43
44
45 def read_tags(tags, 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     if not tags:
53         return []
54
55     tags = tags.strip('/').split('/')
56     real_tags = []
57     while tags:
58         category = tags.pop(0)
59         slug = tags.pop(0)
60
61         try:
62             category = category_singular[category]
63         except KeyError:
64             raise ValueError('Unknown category.')
65
66         if not category in allowed:
67             raise ValueError('Category not allowed.')
68
69         # !^%@#$^#!
70         if category == 'book':
71             slug = 'l-' + slug
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
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
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, top_level=False,
176                 audiobooks=False, daisy=False):
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         try:
186             tags = read_tags(tags, allowed=book_tag_categories)
187         except ValueError:
188             return rc.NOT_FOUND
189
190         if tags:
191             if top_level:
192                 books = Book.tagged_top_level(tags)
193                 return books if books else rc.NOT_FOUND
194             else:
195                 books = Book.tagged.with_all(tags)
196         else:
197             books = Book.objects.all()
198             
199         if top_level:
200             books = books.filter(parent=None)
201         if audiobooks:
202             books = books.filter(media__type='mp3').distinct()
203         if daisy:
204             books = books.filter(media__type='daisy').distinct()
205
206         if books.exists():
207             return books
208         else:
209             return rc.NOT_FOUND
210
211     def create(self, request, *args, **kwargs):
212         return rc.FORBIDDEN
213
214
215 class BooksHandler(BookDetailHandler):
216     allowed_methods = ('GET', 'POST')
217     model = Book
218     fields = book_tag_categories + ['href', 'title', 'url', 'cover', 'cover_thumb']
219     anonymous = AnonymousBooksHandler
220
221     def create(self, request, *args, **kwargs):
222         if not request.user.has_perm('catalogue.add_book'):
223             return rc.FORBIDDEN
224
225         data = json.loads(request.POST.get('data'))
226         form = BookImportForm(data)
227         if form.is_valid():
228             form.save()
229             return rc.CREATED
230         else:
231             return rc.NOT_FOUND
232
233
234 class EBooksHandler(AnonymousBooksHandler):
235     fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats)
236
237
238 # add categorized tags fields for Book
239 def _tags_getter(category):
240     @classmethod
241     def get_tags(cls, book):
242         return book.tags.filter(category=category)
243     return get_tags
244 def _tag_getter(category):
245     @classmethod
246     def get_tag(cls, book):
247         return ", ".join(t[0] for t in book.related_info()['tags'].get(category, []))
248     return get_tag
249 for plural, singular in category_singular.items():
250     setattr(BookDetails, plural, _tags_getter(singular))
251     setattr(BookDetails, singular, _tag_getter(singular))
252
253 # add fields for files in Book
254 def _file_getter(format):
255     field = "%s_file" % format
256     @classmethod
257     def get_file(cls, book):
258         f = getattr(book, field)
259         if f:
260             return MEDIA_BASE + f.url
261         else:
262             return ''
263     return get_file
264 for format in Book.formats:
265     setattr(BookDetails, format, _file_getter(format))
266
267
268 class CollectionDetails(object):
269     """Custom Collection fields."""
270
271     @classmethod
272     def href(cls, collection):
273         """ Returns URI in the API for the collection. """
274
275         return API_BASE + reverse("api_collection", args=[collection.slug])
276
277     @classmethod
278     def url(cls, collection):
279         """ Returns URL on the site. """
280
281         return WL_BASE + collection.get_absolute_url()
282
283     @classmethod
284     def books(cls, collection):
285         return Book.objects.filter(collection.get_query())
286
287
288
289 class CollectionDetailHandler(BaseHandler, CollectionDetails):
290     allowed_methods = ('GET',)
291     fields = ['url', 'title', 'description', 'books']
292
293     @piwik_track
294     def read(self, request, slug):
295         print slug
296         """ Returns details of a collection, identified by slug. """
297         try:
298             return Collection.objects.get(slug=slug)
299         except Collection.DoesNotExist:
300             return rc.NOT_FOUND
301
302
303 class CollectionsHandler(BaseHandler, CollectionDetails):
304     allowed_methods = ('GET',)
305     model = Collection
306     fields = ['url', 'href', 'title']
307
308     @piwik_track
309     def read(self, request):
310         """ Returns all collections. """
311         return Collection.objects.all()
312
313
314 class TagDetails(object):
315     """Custom Tag fields."""
316
317     @classmethod
318     def href(cls, tag):
319         """ Returns URI in the API for the tag. """
320
321         return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
322
323     @classmethod
324     def url(cls, tag):
325         """ Returns URL on the site. """
326
327         return WL_BASE + tag.get_absolute_url()
328
329
330 class TagDetailHandler(BaseHandler, TagDetails):
331     """ Responsible for details of a single Tag object. """
332
333     fields = ['name', 'url', 'sort_key', 'description']
334
335     @piwik_track
336     def read(self, request, category, slug):
337         """ Returns details of a tag, identified by category and slug. """
338
339         try:
340             category_sng = category_singular[category]
341         except KeyError, e:
342             return rc.NOT_FOUND
343
344         try:
345             return Tag.objects.get(category=category_sng, slug=slug)
346         except Tag.DoesNotExist:
347             return rc.NOT_FOUND
348
349
350 class TagsHandler(BaseHandler, TagDetails):
351     """ Main handler for Tag objects.
352
353     Responsible for lists of Tag objects
354     and fields used for representing Tags.
355
356     """
357     allowed_methods = ('GET',)
358     model = Tag
359     fields = ['name', 'href', 'url']
360
361     @piwik_track
362     def read(self, request, category):
363         """ Lists all tags in the category (eg. all themes). """
364
365         try:
366             category_sng = category_singular[category]
367         except KeyError, e:
368             return rc.NOT_FOUND
369
370         tags = Tag.objects.filter(category=category_sng).exclude(book_count=0)
371         if tags.exists():
372             return tags
373         else:
374             return rc.NOT_FOUND
375
376
377 class FragmentDetails(object):
378     """Custom Fragment fields."""
379
380     @classmethod
381     def href(cls, fragment):
382         """ Returns URI in the API for the fragment. """
383
384         return API_BASE + reverse("api_fragment", 
385             args=[fragment.book.slug, fragment.anchor])
386
387     @classmethod
388     def url(cls, fragment):
389         """ Returns URL on the site for the fragment. """
390
391         return WL_BASE + fragment.get_absolute_url()
392
393     @classmethod
394     def themes(cls, fragment):
395         """ Returns a list of theme tags for the fragment. """
396
397         return fragment.tags.filter(category='theme')
398
399
400 class FragmentDetailHandler(BaseHandler, FragmentDetails):
401     fields = ['book', 'anchor', 'text', 'url', 'themes']
402
403     @piwik_track
404     def read(self, request, book, anchor):
405         """ Returns details of a fragment, identified by book slug and anchor. """
406         try:
407             return Fragment.objects.get(book__slug=book, anchor=anchor)
408         except Fragment.DoesNotExist:
409             return rc.NOT_FOUND
410
411
412 class FragmentsHandler(BaseHandler, FragmentDetails):
413     """ Main handler for Fragments.
414
415     Responsible for lists of Fragment objects
416     and fields used for representing Fragments.
417
418     """
419     model = Fragment
420     fields = ['book', 'url', 'anchor', 'href']
421     allowed_methods = ('GET',)
422
423     categories = set(['author', 'epoch', 'kind', 'genre', 'book', 'theme'])
424
425     @piwik_track
426     def read(self, request, tags):
427         """ Lists all fragments with given book, tags, themes.
428
429         :param tags: should be a path of categories and slugs, i.e.:
430              books/book-slug/authors/an-author/themes/a-theme/
431
432         """
433         try:
434             tags = read_tags(tags, allowed=self.categories)
435         except ValueError:
436             return rc.NOT_FOUND
437         fragments = Fragment.tagged.with_all(tags).select_related('book')
438         if fragments.exists():
439             return fragments
440         else:
441             return rc.NOT_FOUND
442
443
444
445 # Changes handlers
446
447 class CatalogueHandler(BaseHandler):
448
449     @staticmethod
450     def fields(request, name):
451         fields_str = request.GET.get(name) if request is not None else None
452         return fields_str.split(',') if fields_str is not None else None
453
454     @staticmethod
455     def until(t=None):
456         """ Returns time suitable for use as upper time boundary for check.
457
458             Used to avoid issues with time between setting the change stamp
459             and actually saving the model in database.
460             Cuts the microsecond part to avoid issues with DBs where time has
461             more precision.
462
463             :param datetime t: manually sets the upper boundary
464
465         """
466         # set to five minutes ago, to avoid concurrency issues
467         if t is None:
468             t = datetime.now() - timedelta(seconds=settings.API_WAIT)
469         # set to whole second in case DB supports something smaller
470         return t.replace(microsecond=0)
471
472     @staticmethod
473     def book_dict(book, fields=None):
474         all_fields = ['url', 'title', 'description',
475                       'gazeta_link', 'wiki_link',
476                       ] + Book.formats + BookMedia.formats.keys() + [
477                       'parent', 'parent_number',
478                       'tags',
479                       'license', 'license_description', 'source_name',
480                       'technical_editors', 'editors',
481                       'author', 'sort_key',
482                      ]
483         if fields:
484             fields = (f for f in fields if f in all_fields)
485         else:
486             fields = all_fields
487
488         extra_info = book.extra_info
489
490         obj = {}
491         for field in fields:
492
493             if field in Book.formats:
494                 f = getattr(book, field+'_file')
495                 if f:
496                     obj[field] = {
497                         'url': f.url,
498                         'size': f.size,
499                     }
500
501             elif field in BookMedia.formats:
502                 media = []
503                 for m in book.media.filter(type=field).iterator():
504                     media.append({
505                         'url': m.file.url,
506                         'size': m.file.size,
507                     })
508                 if media:
509                     obj[field] = media
510
511             elif field == 'url':
512                 obj[field] = book.get_absolute_url()
513
514             elif field == 'tags':
515                 obj[field] = [t.id for t in book.tags.exclude(category__in=('book', 'set')).iterator()]
516
517             elif field == 'author':
518                 obj[field] = ", ".join(t.name for t in book.tags.filter(category='author').iterator())
519
520             elif field == 'parent':
521                 obj[field] = book.parent_id
522
523             elif field in ('license', 'license_description', 'source_name',
524                       'technical_editors', 'editors'):
525                 f = extra_info.get(field)
526                 if f:
527                     obj[field] = f
528
529             else:
530                 f = getattr(book, field)
531                 if f:
532                     obj[field] = f
533
534         obj['id'] = book.id
535         return obj
536
537     @classmethod
538     def book_changes(cls, request=None, since=0, until=None, fields=None):
539         since = datetime.fromtimestamp(int(since))
540         until = cls.until(until)
541
542         changes = {
543             'time_checked': timestamp(until)
544         }
545
546         if not fields:
547             fields = cls.fields(request, 'book_fields')
548
549         added = []
550         updated = []
551         deleted = []
552
553         last_change = since
554         for book in Book.objects.filter(changed_at__gte=since,
555                     changed_at__lt=until).iterator():
556             book_d = cls.book_dict(book, fields)
557             updated.append(book_d)
558         if updated:
559             changes['updated'] = updated
560
561         for book in Deleted.objects.filter(content_type=Book, 
562                     deleted_at__gte=since,
563                     deleted_at__lt=until,
564                     created_at__lt=since).iterator():
565             deleted.append(book.id)
566         if deleted:
567             changes['deleted'] = deleted
568
569         return changes
570
571     @staticmethod
572     def tag_dict(tag, fields=None):
573         all_fields = ('name', 'category', 'sort_key', 'description',
574                       'gazeta_link', 'wiki_link',
575                       'url', 'books',
576                      )
577
578         if fields:
579             fields = (f for f in fields if f in all_fields)
580         else:
581             fields = all_fields
582
583         obj = {}
584         for field in fields:
585
586             if field == 'url':
587                 obj[field] = tag.get_absolute_url()
588
589             elif field == 'books':
590                 obj[field] = [b.id for b in Book.tagged_top_level([tag]).iterator()]
591
592             elif field == 'sort_key':
593                 obj[field] = tag.sort_key
594
595             else:
596                 f = getattr(tag, field)
597                 if f:
598                     obj[field] = f
599
600         obj['id'] = tag.id
601         return obj
602
603     @classmethod
604     def tag_changes(cls, request=None, since=0, until=None, fields=None, categories=None):
605         since = datetime.fromtimestamp(int(since))
606         until = cls.until(until)
607
608         changes = {
609             'time_checked': timestamp(until)
610         }
611
612         if not fields:
613             fields = cls.fields(request, 'tag_fields')
614         if not categories:
615             categories = cls.fields(request, 'tag_categories')
616
617         all_categories = ('author', 'epoch', 'kind', 'genre')
618         if categories:
619             categories = (c for c in categories if c in all_categories)
620         else:
621             categories = all_categories
622
623         updated = []
624         deleted = []
625
626         for tag in Tag.objects.filter(category__in=categories, 
627                     changed_at__gte=since,
628                     changed_at__lt=until).iterator():
629             # only serve non-empty tags
630             if tag.book_count:
631                 tag_d = cls.tag_dict(tag, fields)
632                 updated.append(tag_d)
633             elif tag.created_at < since:
634                 deleted.append(tag.id)
635         if updated:
636             changes['updated'] = updated
637
638         for tag in Deleted.objects.filter(category__in=categories,
639                 content_type=Tag, 
640                     deleted_at__gte=since,
641                     deleted_at__lt=until,
642                     created_at__lt=since).iterator():
643             deleted.append(tag.id)
644         if deleted:
645             changes['deleted'] = deleted
646
647         return changes
648
649     @classmethod
650     def changes(cls, request=None, since=0, until=None, book_fields=None,
651                 tag_fields=None, tag_categories=None):
652         until = cls.until(until)
653         since = int(since)
654
655         if not since:
656             cache = get_cache('api')
657             key = hash((book_fields, tag_fields, tag_categories,
658                     tuple(sorted(request.GET.items()))
659                   ))
660             value = cache.get(key)
661             if value is not None:
662                 return value
663
664         changes = {
665             'time_checked': timestamp(until)
666         }
667
668         changes_by_type = {
669             'books': cls.book_changes(request, since, until, book_fields),
670             'tags': cls.tag_changes(request, since, until, tag_fields, tag_categories),
671         }
672
673         for model in changes_by_type:
674             for field in changes_by_type[model]:
675                 if field == 'time_checked':
676                     continue
677                 changes.setdefault(field, {})[model] = changes_by_type[model][field]
678
679         if not since:
680             cache.set(key, changes)
681
682         return changes
683
684
685 class BookChangesHandler(CatalogueHandler):
686     allowed_methods = ('GET',)
687
688     @piwik_track
689     def read(self, request, since):
690         return self.book_changes(request, since)
691
692
693 class TagChangesHandler(CatalogueHandler):
694     allowed_methods = ('GET',)
695
696     @piwik_track
697     def read(self, request, since):
698         return self.tag_changes(request, since)
699
700
701 class ChangesHandler(CatalogueHandler):
702     allowed_methods = ('GET',)
703
704     @piwik_track
705     def read(self, request, since):
706         return self.changes(request, since)
707
708
709 class PictureHandler(BaseHandler):
710     model = Picture
711     fields = ('slug', 'title')
712     allowed_methods = ('POST',)
713
714     def create(self, request):
715         if not request.user.has_perm('picture.add_picture'):
716             return rc.FORBIDDEN
717
718         data = json.loads(request.POST.get('data'))
719         form = PictureImportForm(data)
720         if form.is_valid():
721             form.save()
722             return rc.CREATED
723         else:
724             return rc.NOT_FOUND