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