apps/api/handlers.py

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