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