Merge branch 'pretty' of github.com:fnp/wolnelektury into pretty
[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
8 from django.conf import settings
9 from django.contrib.sites.models import Site
10 from django.core.cache import get_cache
11 from django.core.urlresolvers import reverse
12 from piston.handler import AnonymousBaseHandler, BaseHandler
13 from piston.utils import rc
14
15 from api.helpers import timestamp
16 from api.models import Deleted
17 from catalogue.forms import BookImportForm
18 from catalogue.models import Book, Tag, BookMedia, Fragment
19 from picture.models import Picture
20 from picture.forms import PictureImportForm
21
22 from stats.utils import piwik_track
23
24 API_BASE = WL_BASE = MEDIA_BASE = 'http://' + Site.objects.get_current().domain
25
26
27 category_singular = {
28     'authors': 'author',
29     'kinds': 'kind',
30     'genres': 'genre',
31     'epochs': 'epoch',
32     'themes': 'theme',
33     'books': 'book',
34 }
35 category_plural={}
36 for k, v in category_singular.items():
37     category_plural[v] = k
38
39
40 def read_tags(tags, allowed):
41     """ Reads a path of filtering tags.
42
43     :param str tags: a path of category and slug pairs, like: authors/an-author/...
44     :returns: list of Tag objects
45     :raises: ValueError when tags can't be found
46     """
47     if not tags:
48         return []
49
50     tags = tags.strip('/').split('/')
51     real_tags = []
52     while tags:
53         category = tags.pop(0)
54         slug = tags.pop(0)
55
56         try:
57             category = category_singular[category]
58         except KeyError:
59             raise ValueError('Unknown category.')
60
61         if not category in allowed:
62             raise ValueError('Category not allowed.')
63
64         # !^%@#$^#!
65         if category == 'book':
66             slug = 'l-' + slug
67
68         try:
69             real_tags.append(Tag.objects.get(category=category, slug=slug))
70         except Tag.DoesNotExist:
71             raise ValueError('Tag not found')
72     return real_tags
73
74
75 # RESTful handlers
76
77
78 class BookMediaHandler(BaseHandler):
79     """ Responsible for representing media in Books. """
80
81     model = BookMedia
82     fields = ['name', 'type', 'url']
83
84     @classmethod
85     def url(cls, media):
86         """ Link to media on site. """
87
88         return MEDIA_BASE + media.file.url
89
90
91 class BookDetailHandler(BaseHandler):
92     """ Main handler for Book objects.
93
94     Responsible for lists of Book objects
95     and fields used for representing Books.
96
97     """
98     allowed_methods = ['GET']
99     fields = ['title', 'parent'] + Book.formats + [
100         'media', 'url'] + category_singular.keys()
101
102     @piwik_track
103     def read(self, request, slug):
104         """ Returns details of a book, identified by a slug and lang. """
105         try:
106             return Book.objects.get(slug=slug)
107         except Book.DoesNotExist:
108             return rc.NOT_FOUND
109
110
111 class AnonymousBooksHandler(AnonymousBaseHandler):
112     """ Main handler for Book objects.
113
114     Responsible for lists of Book objects
115     and fields used for representing Books.
116
117     """
118     allowed_methods = ('GET',)
119     model = Book
120     fields = ['href', 'title']
121
122     categories = set(['author', 'epoch', 'kind', 'genre'])
123
124     @classmethod
125     def href(cls, book):
126         """ Returns an URI for a Book in the API. """
127         return API_BASE + reverse("api_book", args=[book.slug])
128
129     @classmethod
130     def url(cls, book):
131         """ Returns Book's URL on the site. """
132
133         return WL_BASE + book.get_absolute_url()
134
135     @piwik_track
136     def read(self, request, tags, top_level=False):
137         """ Lists all books with given tags.
138
139         :param tags: filtering tags; should be a path of categories
140              and slugs, i.e.: authors/an-author/epoch/an-epoch/
141         :param top_level: if True and a book is included in the results,
142              it's children are aren't. By default all books matching the tags
143              are returned.
144         """
145         tags = read_tags(tags, allowed=self.categories)
146         if tags:
147             if top_level:
148                 books = Book.tagged_top_level(tags)
149                 return books if books else rc.NOT_FOUND
150             else:
151                 books = Book.tagged.with_all(tags)
152         else:
153             books = Book.objects.all()
154
155         if books.exists():
156             return books
157         else:
158             return rc.NOT_FOUND
159
160     def create(self, request, tags, top_level=False):
161         return 'aaa'
162
163     @classmethod
164     def media(self, book):
165         """ Returns all media for a book. """
166
167         return book.media.all()
168
169
170 class BooksHandler(BaseHandler):
171     model = Book
172     fields = ('slug', 'title')
173     anonymous = AnonymousBooksHandler
174
175     def create(self, request, tags, top_level=False):
176         if not request.user.has_perm('catalogue.add_book'):
177             return rc.FORBIDDEN
178
179         data = json.loads(request.POST.get('data'))
180         form = BookImportForm(data)
181         if form.is_valid():
182             form.save()
183             return rc.CREATED
184         else:
185             return rc.NOT_FOUND
186
187 # add categorized tags fields for Book
188 def _tags_getter(category):
189     @classmethod
190     def get_tags(cls, book):
191         return book.tags.filter(category=category)
192     return get_tags
193 for plural, singular in category_singular.items():
194     setattr(BooksHandler, plural, _tags_getter(singular))
195
196 # add fields for files in Book
197 def _file_getter(format):
198     field = "%s_file" % format
199     @classmethod
200     def get_file(cls, book):
201         f = getattr(book, field)
202         if f:
203             return MEDIA_BASE + f.url
204         else:
205             return ''
206     return get_file
207 for format in Book.formats:
208     setattr(BooksHandler, format, _file_getter(format))
209
210
211 class TagDetailHandler(BaseHandler):
212     """ Responsible for details of a single Tag object. """
213
214     fields = ['name', 'sort_key', 'description']
215
216     @piwik_track
217     def read(self, request, category, slug):
218         """ Returns details of a tag, identified by category and slug. """
219
220         try:
221             category_sng = category_singular[category]
222         except KeyError, e:
223             return rc.NOT_FOUND
224
225         try:
226             return Tag.objects.get(category=category_sng, slug=slug)
227         except Tag.DoesNotExist:
228             return rc.NOT_FOUND
229
230
231 class TagsHandler(BaseHandler):
232     """ Main handler for Tag objects.
233
234     Responsible for lists of Tag objects
235     and fields used for representing Tags.
236
237     """
238     allowed_methods = ('GET',)
239     model = Tag
240     fields = ['name', 'href']
241
242     @piwik_track
243     def read(self, request, category):
244         """ Lists all tags in the category (eg. all themes). """
245
246         try:
247             category_sng = category_singular[category]
248         except KeyError, e:
249             return rc.NOT_FOUND
250
251         tags = Tag.objects.filter(category=category_sng).exclude(book_count=0)
252         if tags.exists():
253             return tags
254         else:
255             return rc.NOT_FOUND
256
257
258     @classmethod
259     def href(cls, tag):
260         """ Returns URI in the API for the tag. """
261
262         return API_BASE + reverse("api_tag", args=[category_plural[tag.category], tag.slug])
263
264
265 class FragmentDetailHandler(BaseHandler):
266     fields = ['book', 'anchor', 'text', 'url', 'themes']
267
268     @piwik_track
269     def read(self, request, slug, anchor):
270         """ Returns details of a fragment, identified by book slug and anchor. """
271         try:
272             return Fragment.objects.get(book__slug=slug, anchor=anchor)
273         except Fragment.DoesNotExist:
274             return rc.NOT_FOUND
275
276
277 class FragmentsHandler(BaseHandler):
278     """ Main handler for Fragments.
279
280     Responsible for lists of Fragment objects
281     and fields used for representing Fragments.
282
283     """
284     model = Fragment
285     fields = ['book', 'anchor', 'href']
286     allowed_methods = ('GET',)
287
288     categories = set(['author', 'epoch', 'kind', 'genre', 'book', 'theme'])
289
290     @piwik_track
291     def read(self, request, tags):
292         """ Lists all fragments with given book, tags, themes.
293
294         :param tags: should be a path of categories and slugs, i.e.:
295              books/book-slug/authors/an-author/themes/a-theme/
296
297         """
298         tags = read_tags(tags, allowed=self.categories)
299         fragments = Fragment.tagged.with_all(tags).select_related('book')
300         if fragments.exists():
301             return fragments
302         else:
303             return rc.NOT_FOUND
304
305     @classmethod
306     def href(cls, fragment):
307         """ Returns URI in the API for the fragment. """
308
309         return API_BASE + reverse("api_fragment", 
310             args=[fragment.book.slug, fragment.anchor])
311
312     @classmethod
313     def url(cls, fragment):
314         """ Returns URL on the site for the fragment. """
315
316         return WL_BASE + fragment.get_absolute_url()
317
318     @classmethod
319     def themes(cls, fragment):
320         """ Returns a list of theme tags for the fragment. """
321
322         return fragment.tags.filter(category='theme')
323
324
325
326
327 # Changes handlers
328
329 class CatalogueHandler(BaseHandler):
330
331     @staticmethod
332     def fields(request, name):
333         fields_str = request.GET.get(name) if request is not None else None
334         return fields_str.split(',') if fields_str is not None else None
335
336     @staticmethod
337     def until(t=None):
338         """ Returns time suitable for use as upper time boundary for check.
339
340             Used to avoid issues with time between setting the change stamp
341             and actually saving the model in database.
342             Cuts the microsecond part to avoid issues with DBs where time has
343             more precision.
344
345             :param datetime t: manually sets the upper boundary
346
347         """
348         # set to five minutes ago, to avoid concurrency issues
349         if t is None:
350             t = datetime.now() - timedelta(seconds=settings.API_WAIT)
351         # set to whole second in case DB supports something smaller
352         return t.replace(microsecond=0)
353
354     @staticmethod
355     def book_dict(book, fields=None):
356         all_fields = ['url', 'title', 'description',
357                       'gazeta_link', 'wiki_link',
358                       ] + Book.formats + BookMedia.formats + [
359                       'parent', 'parent_number',
360                       'tags',
361                       'license', 'license_description', 'source_name',
362                       'technical_editors', 'editors',
363                       'author', 'sort_key',
364                      ]
365         if fields:
366             fields = (f for f in fields if f in all_fields)
367         else:
368             fields = all_fields
369
370         extra_info = book.get_extra_info_value()
371
372         obj = {}
373         for field in fields:
374
375             if field in Book.formats:
376                 f = getattr(book, field+'_file')
377                 if f:
378                     obj[field] = {
379                         'url': f.url,
380                         'size': f.size,
381                     }
382
383             elif field in BookMedia.formats:
384                 media = []
385                 for m in book.media.filter(type=field):
386                     media.append({
387                         'url': m.file.url,
388                         'size': m.file.size,
389                     })
390                 if media:
391                     obj[field] = media
392
393             elif field == 'url':
394                 obj[field] = book.get_absolute_url()
395
396             elif field == 'tags':
397                 obj[field] = [t.id for t in book.tags.exclude(category__in=('book', 'set'))]
398
399             elif field == 'author':
400                 obj[field] = ", ".join(t.name for t in book.tags.filter(category='author'))
401
402             elif field == 'parent':
403                 obj[field] = book.parent_id
404
405             elif field in ('license', 'license_description', 'source_name',
406                       'technical_editors', 'editors'):
407                 f = extra_info.get(field)
408                 if f:
409                     obj[field] = f
410
411             else:
412                 f = getattr(book, field)
413                 if f:
414                     obj[field] = f
415
416         obj['id'] = book.id
417         return obj
418
419     @classmethod
420     def book_changes(cls, request=None, since=0, until=None, fields=None):
421         since = datetime.fromtimestamp(int(since))
422         until = cls.until(until)
423
424         changes = {
425             'time_checked': timestamp(until)
426         }
427
428         if not fields:
429             fields = cls.fields(request, 'book_fields')
430
431         added = []
432         updated = []
433         deleted = []
434
435         last_change = since
436         for book in Book.objects.filter(changed_at__gte=since,
437                     changed_at__lt=until):
438             book_d = cls.book_dict(book, fields)
439             updated.append(book_d)
440         if updated:
441             changes['updated'] = updated
442
443         for book in Deleted.objects.filter(content_type=Book, 
444                     deleted_at__gte=since,
445                     deleted_at__lt=until,
446                     created_at__lt=since):
447             deleted.append(book.id)
448         if deleted:
449             changes['deleted'] = deleted
450
451         return changes
452
453     @staticmethod
454     def tag_dict(tag, fields=None):
455         all_fields = ('name', 'category', 'sort_key', 'description',
456                       'gazeta_link', 'wiki_link',
457                       'url', 'books',
458                      )
459
460         if fields:
461             fields = (f for f in fields if f in all_fields)
462         else:
463             fields = all_fields
464
465         obj = {}
466         for field in fields:
467
468             if field == 'url':
469                 obj[field] = tag.get_absolute_url()
470
471             elif field == 'books':
472                 obj[field] = [b.id for b in Book.tagged_top_level([tag])]
473
474             elif field == 'sort_key':
475                 obj[field] = tag.sort_key
476
477             else:
478                 f = getattr(tag, field)
479                 if f:
480                     obj[field] = f
481
482         obj['id'] = tag.id
483         return obj
484
485     @classmethod
486     def tag_changes(cls, request=None, since=0, until=None, fields=None, categories=None):
487         since = datetime.fromtimestamp(int(since))
488         until = cls.until(until)
489
490         changes = {
491             'time_checked': timestamp(until)
492         }
493
494         if not fields:
495             fields = cls.fields(request, 'tag_fields')
496         if not categories:
497             categories = cls.fields(request, 'tag_categories')
498
499         all_categories = ('author', 'epoch', 'kind', 'genre')
500         if categories:
501             categories = (c for c in categories if c in all_categories)
502         else:
503             categories = all_categories
504
505         updated = []
506         deleted = []
507
508         for tag in Tag.objects.filter(category__in=categories, 
509                     changed_at__gte=since,
510                     changed_at__lt=until):
511             # only serve non-empty tags
512             if tag.book_count:
513                 tag_d = cls.tag_dict(tag, fields)
514                 updated.append(tag_d)
515             elif tag.created_at < since:
516                 deleted.append(tag.id)
517         if updated:
518             changes['updated'] = updated
519
520         for tag in Deleted.objects.filter(category__in=categories,
521                 content_type=Tag, 
522                     deleted_at__gte=since,
523                     deleted_at__lt=until,
524                     created_at__lt=since):
525             deleted.append(tag.id)
526         if deleted:
527             changes['deleted'] = deleted
528
529         return changes
530
531     @classmethod
532     def changes(cls, request=None, since=0, until=None, book_fields=None,
533                 tag_fields=None, tag_categories=None):
534         until = cls.until(until)
535         since = int(since)
536
537         if not since:
538             cache = get_cache('api')
539             key = hash((book_fields, tag_fields, tag_categories,
540                     tuple(sorted(request.GET.items()))
541                   ))
542             value = cache.get(key)
543             if value is not None:
544                 return value
545
546         changes = {
547             'time_checked': timestamp(until)
548         }
549
550         changes_by_type = {
551             'books': cls.book_changes(request, since, until, book_fields),
552             'tags': cls.tag_changes(request, since, until, tag_fields, tag_categories),
553         }
554
555         for model in changes_by_type:
556             for field in changes_by_type[model]:
557                 if field == 'time_checked':
558                     continue
559                 changes.setdefault(field, {})[model] = changes_by_type[model][field]
560
561         if not since:
562             cache.set(key, changes)
563
564         return changes
565
566
567 class BookChangesHandler(CatalogueHandler):
568     allowed_methods = ('GET',)
569
570     @piwik_track
571     def read(self, request, since):
572         return self.book_changes(request, since)
573
574
575 class TagChangesHandler(CatalogueHandler):
576     allowed_methods = ('GET',)
577
578     @piwik_track
579     def read(self, request, since):
580         return self.tag_changes(request, since)
581
582
583 class ChangesHandler(CatalogueHandler):
584     allowed_methods = ('GET',)
585
586     @piwik_track
587     def read(self, request, since):
588         return self.changes(request, since)
589
590
591 class PictureHandler(BaseHandler):
592     model = Picture
593     fields = ('slug', 'title')
594     allowed_methods = ('POST',)
595
596     def create(self, request):
597         if not request.user.has_perm('picture.add_picture'):
598             return rc.FORBIDDEN
599
600         data = json.loads(request.POST.get('data'))
601         form = PictureImportForm(data)
602         if form.is_valid():
603             form.save()
604             return rc.CREATED
605         else:
606             return rc.NOT_FOUND