3aefcffa91c3ad726f86acc33d886701081782c5
[wolnelektury.git] / src / api / handlers.py
1 # -*- coding: utf-8 -*-
2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
4 #
5 import json
6
7 from django.contrib.sites.models import Site
8 from django.core.urlresolvers import reverse
9 from django.http.response import HttpResponse
10 from django.utils.functional import lazy
11 from django.db import models
12 from migdal.models import Entry
13 from piston.handler import AnonymousBaseHandler, BaseHandler
14 from piston.utils import rc
15 from sorl.thumbnail import default
16
17 from api.models import BookUserData
18 from catalogue.forms import BookImportForm
19 from catalogue.models import Book, Tag, BookMedia, Fragment, Collection
20 from catalogue.models.tag import prefetch_relations
21 from catalogue.utils import is_subscribed
22 from 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, 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 'count' in request.GET:
230             count = request.GET['count']
231
232         if tags:
233             if top_level:
234                 books = Book.tagged_top_level(tags)
235                 return books if books else rc.NOT_FOUND
236             else:
237                 books = Book.tagged.with_all(tags)
238         else:
239             books = books if books is not None else Book.objects.all()
240         books = books.order_by('slug')
241
242         if top_level:
243             books = books.filter(parent=None)
244         if audiobooks:
245             books = books.filter(media__type='mp3').distinct()
246         if daisy:
247             books = books.filter(media__type='daisy').distinct()
248         if recommended:
249             books = books.filter(recommended=True)
250         if newest:
251             books = books.order_by('-created_at')
252
253         # beznadzieja
254         if after:
255             books = books.filter(slug__gt=after)
256
257         books = books.only('slug', 'title', 'cover', 'cover_thumb')
258         for category in book_tag_categories:
259             books = prefetch_relations(books, category)
260
261         if count:
262             books = books[:count]
263
264         return books
265
266     def create(self, request, *args, **kwargs):
267         return rc.FORBIDDEN
268
269
270 class BooksHandler(BookDetailHandler):
271     allowed_methods = ('GET', 'POST')
272     model = Book
273     fields = book_list_fields + ['liked']
274     anonymous = AnonymousBooksHandler
275
276     # hack, because piston is stupid
277     @classmethod
278     def liked(cls, book):
279         return getattr(book, 'liked', None)
280
281     def read(self, request, **kwargs):
282         books = AnonymousBooksHandler().read(request, **kwargs)
283         likes = set(Book.tagged.with_any(request.user.tag_set.all()).values_list('id', flat=True))
284
285         new_books = [
286             BookProxy(book).set('liked', book.id in likes)
287             for book in books]
288         return QuerySetProxy(new_books)
289
290     def create(self, request, *args, **kwargs):
291         if not request.user.has_perm('catalogue.add_book'):
292             return rc.FORBIDDEN
293
294         data = json.loads(request.POST.get('data'))
295         form = BookImportForm(data)
296         if form.is_valid():
297             form.save()
298             return rc.CREATED
299         else:
300             return rc.NOT_FOUND
301
302
303 class EpubHandler(BookDetailHandler):
304     def read(self, request, slug):
305         if not is_subscribed(request.user):
306             return rc.FORBIDDEN
307         try:
308             book = Book.objects.get(slug=slug)
309         except Book.DoesNotExist:
310             return rc.NOT_FOUND
311         response = HttpResponse(book.get_media('epub'))
312         return response
313
314
315 class EBooksHandler(AnonymousBooksHandler):
316     fields = ('author', 'href', 'title', 'cover') + tuple(Book.ebook_formats) + ('slug',)
317
318
319 class BookProxy(models.Model):
320     class Meta:
321         managed = False
322
323     def __init__(self, book, key=None):
324         self.book = book
325         self.key = key
326
327     def set(self, attr, value):
328         self.__setattr__(attr, value)
329         return self
330
331     def __getattr__(self, item):
332         return self.book.__getattribute__(item)
333
334
335 class QuerySetProxy(models.QuerySet):
336     def __init__(self, l):
337         self.list = l
338
339     def __iter__(self):
340         return iter(self.list)
341
342
343 class AnonFilterBooksHandler(AnonymousBooksHandler):
344     fields = book_list_fields + ['key']
345
346     def parse_bool(self, s):
347         if s in ('true', 'false'):
348             return s == 'true'
349         else:
350             return None
351
352     def read(self, request):
353         key_sep = '$'
354         search_string = request.GET.get('search')
355         is_lektura = self.parse_bool(request.GET.get('lektura'))
356         is_audiobook = self.parse_bool(request.GET.get('audiobook'))
357         preview = self.parse_bool(request.GET.get('preview'))
358
359         after = request.GET.get('after')
360         count = int(request.GET.get('count', 50))
361         books = Book.objects.distinct().order_by('slug')
362         if is_lektura is not None:
363             books = books.filter(has_audience=is_lektura)
364         if is_audiobook is not None:
365             if is_audiobook:
366                 books = books.filter(media__type='mp3')
367             else:
368                 books = books.exclude(media__type='mp3')
369         if preview is not None:
370             books = books.filter(preview=preview)
371         for key in request.GET:
372             if key in category_singular:
373                 category = category_singular[key]
374                 if category in book_tag_categories:
375                     slugs = request.GET[key].split(',')
376                     tags = Tag.objects.filter(category=category, slug__in=slugs)
377                     books = Book.tagged.with_any(tags, books)
378         if (search_string is not None) and len(search_string) < 3:
379             search_string = None
380         if search_string:
381             search_string = re_escape(search_string)
382             books_author = books.filter(cached_author__iregex='\m' + search_string)
383             books_title = books.filter(title__iregex='\m' + search_string)
384             books_title = books_title.exclude(id__in=list(books_author.values_list('id', flat=True)))
385             if after and (key_sep in after):
386                 which, slug = after.split(key_sep, 1)
387                 if which == 'title':
388                     book_lists = [(books_title.filter(slug__gt=slug), 'title')]
389                 else:  # which == 'author'
390                     book_lists = [(books_author.filter(slug__gt=slug), 'author'), (books_title, 'title')]
391             else:
392                 book_lists = [(books_author, 'author'), (books_title, 'title')]
393         else:
394             if after and key_sep in after:
395                 which, slug = after.split(key_sep, 1)
396                 books = books.filter(slug__gt=slug)
397             book_lists = [(books, 'book')]
398
399         filtered_books = []
400         for book_list, label in book_lists:
401             book_list = book_list.only('slug', 'title', 'cover', 'cover_thumb')
402             for category in book_tag_categories:
403                 book_list = prefetch_relations(book_list, category)
404             remaining_count = count - len(filtered_books)
405             new_books = [BookProxy(book, '%s%s%s' % (label, key_sep, book.slug))
406                          for book in book_list[:remaining_count]]
407             filtered_books += new_books
408             if len(filtered_books) == count:
409                 break
410
411         return QuerySetProxy(filtered_books)
412
413
414 class FilterBooksHandler(BooksHandler):
415     anonymous = AnonFilterBooksHandler
416     fields = book_list_fields + ['key', 'liked']
417
418     # hack, because piston is stupid
419     @classmethod
420     def liked(cls, book):
421         return getattr(book, 'liked', None)
422
423     def read(self, request):
424         qsp = AnonFilterBooksHandler().read(request)
425         likes = set(Book.tagged.with_any(request.user.tag_set.all()).values_list('id', flat=True))
426         for book in qsp.list:
427             book.set('liked', book.id in likes)
428         return qsp
429
430
431 class BookPreviewHandler(BookDetailHandler):
432     fields = BookDetailHandler.fields + ['slug']
433
434     def read(self, request):
435         return Book.objects.filter(preview=True)
436
437
438 # add categorized tags fields for Book
439 def _tags_getter(category):
440     @classmethod
441     def get_tags(cls, book):
442         return book.tags.filter(category=category)
443     return get_tags
444
445
446 def _tag_getter(category):
447     @classmethod
448     def get_tag(cls, book):
449         return book.tag_unicode(category)
450     return get_tag
451
452
453 def add_tag_getters():
454     for plural, singular in category_singular.items():
455         setattr(BookDetails, plural, _tags_getter(singular))
456         setattr(BookDetails, singular, _tag_getter(singular))
457
458
459 add_tag_getters()
460
461
462 # add fields for files in Book
463 def _file_getter(book_format):
464
465     @staticmethod
466     def get_file(book):
467         f_url = book.media_url(book_format)
468         if f_url:
469             return MEDIA_BASE + f_url
470         else:
471             return ''
472     return get_file
473
474
475 def add_file_getters():
476     for book_format in Book.formats:
477         setattr(BookDetails, book_format, _file_getter(book_format))
478
479
480 add_file_getters()
481
482
483 class CollectionDetails(object):
484     """Custom Collection fields."""
485
486     @classmethod
487     def href(cls, collection):
488         """ Returns URI in the API for the collection. """
489
490         return API_BASE + reverse("api_collection", args=[collection.slug])
491
492     @classmethod
493     def url(cls, collection):
494         """ Returns URL on the site. """
495
496         return WL_BASE + collection.get_absolute_url()
497
498     @classmethod
499     def books(cls, collection):
500         return Book.objects.filter(collection.get_query())
501
502
503 class CollectionDetailHandler(BaseHandler, CollectionDetails):
504     allowed_methods = ('GET',)
505     fields = ['url', 'title', 'description', 'books']
506
507     @piwik_track
508     def read(self, request, slug):
509         """ Returns details of a collection, identified by slug. """
510         try:
511             return Collection.objects.get(slug=slug)
512         except Collection.DoesNotExist:
513             return rc.NOT_FOUND
514
515
516 class CollectionsHandler(BaseHandler, CollectionDetails):
517     allowed_methods = ('GET',)
518     model = Collection
519     fields = ['url', 'href', 'title']
520
521     @piwik_track
522     def read(self, request):
523         """ Returns all collections. """
524         return Collection.objects.all()
525
526
527 class TagDetails(object):
528     """Custom Tag fields."""
529
530     @classmethod
531     def href(cls, tag):
532         """ Returns URI in the API for the tag. """
533
534         return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
535
536     @classmethod
537     def url(cls, tag):
538         """ Returns URL on the site. """
539
540         return WL_BASE + tag.get_absolute_url()
541
542
543 class TagDetailHandler(BaseHandler, TagDetails):
544     """ Responsible for details of a single Tag object. """
545
546     fields = ['name', 'url', 'sort_key', 'description']
547
548     @piwik_track
549     def read(self, request, category, slug):
550         """ Returns details of a tag, identified by category and slug. """
551
552         try:
553             category_sng = category_singular[category]
554         except KeyError:
555             return rc.NOT_FOUND
556
557         try:
558             return Tag.objects.get(category=category_sng, slug=slug)
559         except Tag.DoesNotExist:
560             return rc.NOT_FOUND
561
562
563 class TagsHandler(BaseHandler, TagDetails):
564     """ Main handler for Tag objects.
565
566     Responsible for lists of Tag objects
567     and fields used for representing Tags.
568
569     """
570     allowed_methods = ('GET',)
571     model = Tag
572     fields = ['name', 'href', 'url', 'slug']
573
574     @piwik_track
575     def read(self, request, category=None, pk=None):
576         """ Lists all tags in the category (eg. all themes). """
577         if pk is not None:
578             try:
579                 return Tag.objects.exclude(category='set').get(pk=pk)
580             except Book.DoesNotExist:
581                 return rc.NOT_FOUND
582
583         try:
584             category_sng = category_singular[category]
585         except KeyError:
586             return rc.NOT_FOUND
587
588         after = request.GET.get('after')
589         count = request.GET.get('count')
590
591         tags = Tag.objects.filter(category=category_sng).exclude(items=None).order_by('slug')
592
593         book_only = request.GET.get('book_only') == 'true'
594         picture_only = request.GET.get('picture_only') == 'true'
595         if book_only:
596             tags = tags.filter(for_books=True)
597         if picture_only:
598             tags = tags.filter(for_pictures=True)
599
600         if after:
601             tags = tags.filter(slug__gt=after)
602
603         if count:
604             tags = tags[:count]
605
606         return tags
607
608
609 class FragmentDetails(object):
610     """Custom Fragment fields."""
611
612     @classmethod
613     def href(cls, fragment):
614         """ Returns URI in the API for the fragment. """
615
616         return API_BASE + reverse("api_fragment", args=[fragment.book.slug, fragment.anchor])
617
618     @classmethod
619     def url(cls, fragment):
620         """ Returns URL on the site for the fragment. """
621
622         return WL_BASE + fragment.get_absolute_url()
623
624     @classmethod
625     def themes(cls, fragment):
626         """ Returns a list of theme tags for the fragment. """
627
628         return fragment.tags.filter(category='theme')
629
630
631 class FragmentDetailHandler(BaseHandler, FragmentDetails):
632     fields = ['book', 'anchor', 'text', 'url', 'themes']
633
634     @piwik_track
635     def read(self, request, book, anchor):
636         """ Returns details of a fragment, identified by book slug and anchor. """
637         try:
638             return Fragment.objects.get(book__slug=book, anchor=anchor)
639         except Fragment.DoesNotExist:
640             return rc.NOT_FOUND
641
642
643 class FragmentsHandler(BaseHandler, FragmentDetails):
644     """ Main handler for Fragments.
645
646     Responsible for lists of Fragment objects
647     and fields used for representing Fragments.
648
649     """
650     model = Fragment
651     fields = ['book', 'url', 'anchor', 'href']
652     allowed_methods = ('GET',)
653
654     categories = {'author', 'epoch', 'kind', 'genre', 'book', 'theme'}
655
656     @piwik_track
657     def read(self, request, tags):
658         """ Lists all fragments with given book, tags, themes.
659
660         :param tags: should be a path of categories and slugs, i.e.:
661              books/book-slug/authors/an-author/themes/a-theme/
662
663         """
664         try:
665             tags, ancestors = read_tags(tags, request, allowed=self.categories)
666         except ValueError:
667             return rc.NOT_FOUND
668         fragments = Fragment.tagged.with_all(tags).select_related('book')
669         if fragments.exists():
670             return fragments
671         else:
672             return rc.NOT_FOUND
673
674
675 class PictureHandler(BaseHandler):
676     model = Picture
677     fields = ('slug', 'title')
678     allowed_methods = ('POST',)
679
680     def create(self, request):
681         if not request.user.has_perm('picture.add_picture'):
682             return rc.FORBIDDEN
683
684         data = json.loads(request.POST.get('data'))
685         form = PictureImportForm(data)
686         if form.is_valid():
687             form.save()
688             return rc.CREATED
689         else:
690             return rc.NOT_FOUND
691
692
693 class UserDataHandler(BaseHandler):
694     model = BookUserData
695     fields = ('state', 'username', 'premium')
696     allowed_methods = ('GET', 'POST')
697
698     def read(self, request, slug=None):
699         if not request.user.is_authenticated():
700             return rc.FORBIDDEN
701         if slug is None:
702             return {'username': request.user.username, 'premium': is_subscribed(request.user)}
703         try:
704             book = Book.objects.get(slug=slug)
705         except Book.DoesNotExist:
706             return rc.NOT_FOUND
707         try:
708             data = BookUserData.objects.get(book=book, user=request.user)
709         except BookUserData.DoesNotExist:
710             return {'state': 'not_started'}
711         return data
712
713     def create(self, request, slug, state):
714         try:
715             book = Book.objects.get(slug=slug)
716         except Book.DoesNotExist:
717             return rc.NOT_FOUND
718         if not request.user.is_authenticated():
719             return rc.FORBIDDEN
720         if state not in ('reading', 'complete'):
721             return rc.NOT_FOUND
722         data, created = BookUserData.objects.get_or_create(book=book, user=request.user)
723         data.state = state
724         data.save()
725         return data
726
727
728 class UserShelfHandler(BookDetailHandler):
729     fields = book_list_fields + ['liked']
730
731     def parse_bool(self, s):
732         if s in ('true', 'false'):
733             return s == 'true'
734         else:
735             return None
736
737     # hack, because piston is stupid
738     @classmethod
739     def liked(cls, book):
740         return getattr(book, 'liked', None)
741
742     def read(self, request, state):
743         if not request.user.is_authenticated():
744             return rc.FORBIDDEN
745         likes = set(Book.tagged.with_any(request.user.tag_set.all()).values_list('id', flat=True))
746         if state not in ('reading', 'complete', 'likes'):
747             return rc.NOT_FOUND
748         after = request.GET.get('after')
749         count = int(request.GET.get('count', 50))
750         if state == 'likes':
751             books = Book.tagged.with_any(request.user.tag_set.all())
752         else:
753             ids = BookUserData.objects.filter(user=request.user, complete=state == 'complete')\
754                 .values_list('book_id', flat=True)
755             books = Book.objects.filter(id__in=list(ids)).distinct().order_by('slug')
756         if after:
757             books = books.filter(slug__gt=after)
758         if count:
759             books = books[:count]
760         new_books = []
761         for book in books:
762             new_books.append(BookProxy(book).set('liked', book.id in likes))
763         return QuerySetProxy(new_books)
764
765
766 class UserLikeHandler(BaseHandler):
767     fields = []
768     allowed_methods = ('GET', 'POST')
769
770     def read(self, request, slug):
771         if not request.user.is_authenticated():
772             return rc.FORBIDDEN
773         try:
774             book = Book.objects.get(slug=slug)
775         except Book.DoesNotExist:
776             return rc.NOT_FOUND
777         return {'likes': likes(request.user, book)}
778
779     def create(self, request, slug):
780         if not request.user.is_authenticated():
781             return rc.FORBIDDEN
782         try:
783             book = Book.objects.get(slug=slug)
784         except Book.DoesNotExist:
785             return rc.NOT_FOUND
786         action = request.GET.get('action', 'like')
787         if action == 'like':
788             book.like(request.user)
789         elif action == 'unlike':
790             book.unlike(request.user)
791         return {}
792
793
794 class BlogEntryHandler(BaseHandler):
795     model = Entry
796     fields = (
797         'title', 'lead', 'body', 'place', 'time', 'image_url', 'image_thumb', 'gallery_urls', 'type', 'key', 'url')
798
799     def read(self, request):
800         after = request.GET.get('after')
801         count = int(request.GET.get('count', 20))
802         entries = Entry.published_objects.filter(in_stream=True).order_by('-first_published_at')
803         if after:
804             entries = entries.filter(first_published_at__lt=after)
805         if count:
806             entries = entries[:count]
807         return entries
808
809     @classmethod
810     def image_url(cls, entry):
811         return (WL_BASE + entry.image.url) if entry.image else None
812
813     @classmethod
814     def image_thumb(cls, entry):
815         return MEDIA_BASE + default.backend.get_thumbnail(
816             entry.image, "193x193").url if entry.image else ''
817
818     @classmethod
819     def gallery_urls(cls, entry):
820         return [WL_BASE + photo.url() for photo in entry.photo_set.all()]
821
822     @classmethod
823     def key(cls, entry):
824         return entry.first_published_at
825
826     @classmethod
827     def url(cls, entry):
828         return WL_BASE + entry.get_absolute_url()