apps/catalogue/views.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 tempfile
   6 import zipfile
   7 import tarfile
   8 import sys
   9 import pprint
  10 import traceback
  11 import re
  12 import itertools
  13 from datetime import datetime
  14
  15 from django.conf import settings
  16 from django.template import RequestContext
  17 from django.shortcuts import render_to_response, get_object_or_404
  18 from django.http import HttpResponse, HttpResponseRedirect, Http404
  19 from django.core.urlresolvers import reverse
  20 from django.db.models import Q
  21 from django.contrib.auth.decorators import login_required, user_passes_test
  22 from django.utils.datastructures import SortedDict
  23 from django.views.decorators.http import require_POST
  24 from django.contrib import auth
  25 from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
  26 from django.utils import simplejson
  27 from django.utils.functional import Promise
  28 from django.utils.encoding import force_unicode
  29 from django.utils.http import urlquote_plus
  30 from django.views.decorators import cache
  31 from django.utils.translation import ugettext as _
  32 from django.views.generic.list_detail import object_list
  33
  34 from catalogue import models
  35 from catalogue import forms
  36 from catalogue.utils import split_tags
  37 from newtagging import views as newtagging_views
  38 from pdcounter import models as pdcounter_models
  39 from pdcounter import views as pdcounter_views
  40 from slughifi import slughifi
  41
  42
  43 staff_required = user_passes_test(lambda user: user.is_staff)
  44
  45
  46 class LazyEncoder(simplejson.JSONEncoder):
  47     def default(self, obj):
  48         if isinstance(obj, Promise):
  49             return force_unicode(obj)
  50         return obj
  51
  52 # shortcut for JSON reponses
  53 class JSONResponse(HttpResponse):
  54     def __init__(self, data={}, callback=None, **kwargs):
  55         # get rid of mimetype
  56         kwargs.pop('mimetype', None)
  57         data = simplejson.dumps(data)
  58         if callback:
  59             data = callback + "(" + data + ");"
  60         super(JSONResponse, self).__init__(data, mimetype="application/json", **kwargs)
  61
  62
  63 def main_page(request):
  64     if request.user.is_authenticated():
  65         shelves = models.Tag.objects.filter(category='set', user=request.user)
  66         new_set_form = forms.NewSetForm()
  67
  68     tags = models.Tag.objects.exclude(category__in=('set', 'book'))
  69     for tag in tags:
  70         tag.count = tag.get_count()
  71     categories = split_tags(tags)
  72     fragment_tags = categories.get('theme', [])
  73
  74     form = forms.SearchForm()
  75     return render_to_response('catalogue/main_page.html', locals(),
  76         context_instance=RequestContext(request))
  77
  78
  79 def book_list(request, filter=None, template_name='catalogue/book_list.html'):
  80     """ generates a listing of all books, optionally filtered with a test function """
  81
  82     form = forms.SearchForm()
  83
  84     books_by_parent = {}
  85     books = models.Book.objects.all().order_by('parent_number', 'title').only('title', 'parent', 'slug')
  86     if filter:
  87         books = books.filter(filter).distinct()
  88         book_ids = set((book.pk for book in books))
  89         for book in books:
  90             parent = book.parent_id
  91             if parent not in book_ids:
  92                 parent = None
  93             books_by_parent.setdefault(parent, []).append(book)
  94     else:
  95         for book in books:
  96             books_by_parent.setdefault(book.parent_id, []).append(book)
  97
  98     orphans = []
  99     books_by_author = SortedDict()
 100     books_nav = SortedDict()
 101     for tag in models.Tag.objects.filter(category='author'):
 102         books_by_author[tag] = []
 103
 104     for book in books_by_parent.get(None,()):
 105         authors = list(book.tags.filter(category='author'))
 106         if authors:
 107             for author in authors:
 108                 books_by_author[author].append(book)
 109         else:
 110             orphans.append(book)
 111
 112     for tag in books_by_author:
 113         if books_by_author[tag]:
 114             books_nav.setdefault(tag.sort_key[0], []).append(tag)
 115
 116     return render_to_response(template_name, locals(),
 117         context_instance=RequestContext(request))
 118
 119
 120 def audiobook_list(request):
 121     return book_list(request, Q(medias__type='mp3') | Q(medias__type='ogg'),
 122                      template_name='catalogue/audiobook_list.html')
 123
 124
 125 def daisy_list(request):
 126     return book_list(request, Q(medias__type='daisy'),
 127                      template_name='catalogue/daisy_list.html')
 128
 129
 130 def differentiate_tags(request, tags, ambiguous_slugs):
 131     beginning = '/'.join(tag.url_chunk for tag in tags)
 132     unparsed = '/'.join(ambiguous_slugs[1:])
 133     options = []
 134     for tag in models.Tag.objects.exclude(category='book').filter(slug=ambiguous_slugs[0]):
 135         options.append({
 136             'url_args': '/'.join((beginning, tag.url_chunk, unparsed)).strip('/'),
 137             'tags': [tag]
 138         })
 139     return render_to_response('catalogue/differentiate_tags.html',
 140                 {'tags': tags, 'options': options, 'unparsed': ambiguous_slugs[1:]},
 141                 context_instance=RequestContext(request))
 142
 143
 144 def tagged_object_list(request, tags=''):
 145     try:
 146         tags = models.Tag.get_tag_list(tags)
 147     except models.Tag.DoesNotExist:
 148         chunks = tags.split('/')
 149         if len(chunks) == 2 and chunks[0] == 'autor':
 150             return pdcounter_views.author_detail(request, chunks[1])
 151         else:
 152             raise Http404
 153     except models.Tag.MultipleObjectsReturned, e:
 154         return differentiate_tags(request, e.tags, e.ambiguous_slugs)
 155
 156     try:
 157         if len(tags) > settings.MAX_TAG_LIST:
 158             raise Http404
 159     except AttributeError:
 160         pass
 161
 162     if len([tag for tag in tags if tag.category == 'book']):
 163         raise Http404
 164
 165     theme_is_set = [tag for tag in tags if tag.category == 'theme']
 166     shelf_is_set = [tag for tag in tags if tag.category == 'set']
 167     only_shelf = shelf_is_set and len(tags) == 1
 168     only_my_shelf = only_shelf and request.user.is_authenticated() and request.user == tags[0].user
 169
 170     objects = only_author = None
 171     categories = {}
 172
 173     if theme_is_set:
 174         shelf_tags = [tag for tag in tags if tag.category == 'set']
 175         fragment_tags = [tag for tag in tags if tag.category != 'set']
 176         fragments = models.Fragment.tagged.with_all(fragment_tags)
 177
 178         if shelf_tags:
 179             books = models.Book.tagged.with_all(shelf_tags).order_by()
 180             l_tags = models.Tag.objects.filter(category='book', slug__in=[book.book_tag_slug() for book in books])
 181             fragments = models.Fragment.tagged.with_any(l_tags, fragments)
 182
 183         # newtagging goes crazy if we just try:
 184         #related_tags = models.Tag.objects.usage_for_queryset(fragments, counts=True,
 185         #                    extra={'where': ["catalogue_tag.category != 'book'"]})
 186         fragment_keys = [fragment.pk for fragment in fragments]
 187         if fragment_keys:
 188             related_tags = models.Fragment.tags.usage(counts=True,
 189                                 filters={'pk__in': fragment_keys},
 190                                 extra={'where': ["catalogue_tag.category != 'book'"]})
 191             related_tags = (tag for tag in related_tags if tag not in fragment_tags)
 192             categories = split_tags(related_tags)
 193
 194             objects = fragments
 195     else:
 196         # get relevant books and their tags
 197         objects = models.Book.tagged.with_all(tags)
 198         if not shelf_is_set:
 199             # eliminate descendants
 200             l_tags = models.Tag.objects.filter(category='book', slug__in=[book.book_tag_slug() for book in objects])
 201             descendants_keys = [book.pk for book in models.Book.tagged.with_any(l_tags)]
 202             if descendants_keys:
 203                 objects = objects.exclude(pk__in=descendants_keys)
 204
 205         # get related tags from `tag_counter` and `theme_counter`
 206         related_counts = {}
 207         tags_pks = [tag.pk for tag in tags]
 208         for book in objects:
 209             for tag_pk, value in itertools.chain(book.tag_counter.iteritems(), book.theme_counter.iteritems()):
 210                 if tag_pk in tags_pks:
 211                     continue
 212                 related_counts[tag_pk] = related_counts.get(tag_pk, 0) + value
 213         related_tags = models.Tag.objects.filter(pk__in=related_counts.keys())
 214         related_tags = [tag for tag in related_tags if tag not in tags]
 215         for tag in related_tags:
 216             tag.count = related_counts[tag.pk]
 217
 218         categories = split_tags(related_tags)
 219         del related_tags
 220
 221     if not objects:
 222         only_author = len(tags) == 1 and tags[0].category == 'author'
 223         objects = models.Book.objects.none()
 224
 225     return object_list(
 226         request,
 227         objects,
 228         template_name='catalogue/tagged_object_list.html',
 229         extra_context={
 230             'categories': categories,
 231             'only_shelf': only_shelf,
 232             'only_author': only_author,
 233             'only_my_shelf': only_my_shelf,
 234             'formats_form': forms.DownloadFormatsForm(),
 235
 236             'tags': tags,
 237         }
 238     )
 239
 240
 241 def book_fragments(request, book_slug, theme_slug):
 242     book = get_object_or_404(models.Book, slug=book_slug)
 243     book_tag = get_object_or_404(models.Tag, slug='l-' + book_slug, category='book')
 244     theme = get_object_or_404(models.Tag, slug=theme_slug, category='theme')
 245     fragments = models.Fragment.tagged.with_all([book_tag, theme])
 246
 247     form = forms.SearchForm()
 248     return render_to_response('catalogue/book_fragments.html', locals(),
 249         context_instance=RequestContext(request))
 250
 251
 252 def book_detail(request, slug):
 253     try:
 254         book = models.Book.objects.get(slug=slug)
 255     except models.Book.DoesNotExist:
 256         return pdcounter_views.book_stub_detail(request, slug)
 257
 258     book_tag = book.book_tag()
 259     tags = list(book.tags.filter(~Q(category='set')))
 260     categories = split_tags(tags)
 261     book_children = book.children.all().order_by('parent_number', 'title')
 262
 263     _book = book
 264     parents = []
 265     while _book.parent:
 266         parents.append(_book.parent)
 267         _book = _book.parent
 268     parents = reversed(parents)
 269
 270     theme_counter = book.theme_counter
 271     book_themes = models.Tag.objects.filter(pk__in=theme_counter.keys())
 272     for tag in book_themes:
 273         tag.count = theme_counter[tag.pk]
 274
 275     extra_info = book.get_extra_info_value()
 276
 277     form = forms.SearchForm()
 278     return render_to_response('catalogue/book_detail.html', locals(),
 279         context_instance=RequestContext(request))
 280
 281
 282 def book_text(request, slug):
 283     book = get_object_or_404(models.Book, slug=slug)
 284     if not book.has_html_file():
 285         raise Http404
 286     book_themes = {}
 287     for fragment in book.fragments.all():
 288         for theme in fragment.tags.filter(category='theme'):
 289             book_themes.setdefault(theme, []).append(fragment)
 290
 291     book_themes = book_themes.items()
 292     book_themes.sort(key=lambda s: s[0].sort_key)
 293     return render_to_response('catalogue/book_text.html', locals(),
 294         context_instance=RequestContext(request))
 295
 296
 297 # ==========
 298 # = Search =
 299 # ==========
 300
 301 def _no_diacritics_regexp(query):
 302     """ returns a regexp for searching for a query without diacritics
 303
 304     should be locale-aware """
 305     names = {
 306         u'a':u'aąĄ', u'c':u'cćĆ', u'e':u'eęĘ', u'l': u'lłŁ', u'n':u'nńŃ', u'o':u'oóÓ', u's':u'sśŚ', u'z':u'zźżŹŻ',
 307         u'ą':u'ąĄ', u'ć':u'ćĆ', u'ę':u'ęĘ', u'ł': u'łŁ', u'ń':u'ńŃ', u'ó':u'óÓ', u'ś':u'śŚ', u'ź':u'źŹ', u'ż':u'żŻ'
 308         }
 309     def repl(m):
 310         l = m.group()
 311         return u"(%s)" % '|'.join(names[l])
 312     return re.sub(u'[%s]' % (u''.join(names.keys())), repl, query)
 313
 314 def unicode_re_escape(query):
 315     """ Unicode-friendly version of re.escape """
 316     return re.sub('(?u)(\W)', r'\\\1', query)
 317
 318 def _word_starts_with(name, prefix):
 319     """returns a Q object getting models having `name` contain a word
 320     starting with `prefix`
 321
 322     We define word characters as alphanumeric and underscore, like in JS.
 323
 324     Works for MySQL, PostgreSQL, Oracle.
 325     For SQLite, _sqlite* version is substituted for this.
 326     """
 327     kwargs = {}
 328
 329     prefix = _no_diacritics_regexp(unicode_re_escape(prefix))
 330     # can't use [[:<:]] (word start),
 331     # but we want both `xy` and `(xy` to catch `(xyz)`
 332     kwargs['%s__iregex' % name] = u"(^|[^[:alnum:]_])%s" % prefix
 333
 334     return Q(**kwargs)
 335
 336
 337 def _word_starts_with_regexp(prefix):
 338     prefix = _no_diacritics_regexp(unicode_re_escape(prefix))
 339     return ur"(^|(?<=[^\wąćęłńóśźżĄĆĘŁŃÓŚŹŻ]))%s" % prefix
 340
 341
 342 def _sqlite_word_starts_with(name, prefix):
 343     """ version of _word_starts_with for SQLite
 344
 345     SQLite in Django uses Python re module
 346     """
 347     kwargs = {}
 348     kwargs['%s__iregex' % name] = _word_starts_with_regexp(prefix)
 349     return Q(**kwargs)
 350
 351
 352 if hasattr(settings, 'DATABASES'):
 353     if settings.DATABASES['default']['ENGINE'] == 'django.db.backends.sqlite3':
 354         _word_starts_with = _sqlite_word_starts_with
 355 elif settings.DATABASE_ENGINE == 'sqlite3':
 356     _word_starts_with = _sqlite_word_starts_with
 357
 358
 359 class App():
 360     def __init__(self, name, view):
 361         self.name = name
 362         self._view = view
 363         self.lower = name.lower()
 364         self.category = 'application'
 365     def view(self):
 366         return reverse(*self._view)
 367
 368 _apps = (
 369     App(u'Leśmianator', (u'lesmianator', )),
 370     )
 371
 372
 373 def _tags_starting_with(prefix, user=None):
 374     prefix = prefix.lower()
 375     # PD counter
 376     book_stubs = pdcounter_models.BookStub.objects.filter(_word_starts_with('title', prefix))
 377     authors = pdcounter_models.Author.objects.filter(_word_starts_with('name', prefix))
 378
 379     books = models.Book.objects.filter(_word_starts_with('title', prefix))
 380     tags = models.Tag.objects.filter(_word_starts_with('name', prefix))
 381     if user and user.is_authenticated():
 382         tags = tags.filter(~Q(category='book') & (~Q(category='set') | Q(user=user)))
 383     else:
 384         tags = tags.filter(~Q(category='book') & ~Q(category='set'))
 385
 386     prefix_regexp = re.compile(_word_starts_with_regexp(prefix))
 387     return list(books) + list(tags) + [app for app in _apps if prefix_regexp.search(app.lower)] + list(book_stubs) + list(authors)
 388
 389
 390 def _get_result_link(match, tag_list):
 391     if isinstance(match, models.Tag):
 392         return reverse('catalogue.views.tagged_object_list',
 393             kwargs={'tags': '/'.join(tag.url_chunk for tag in tag_list + [match])}
 394         )
 395     elif isinstance(match, App):
 396         return match.view()
 397     else:
 398         return match.get_absolute_url()
 399
 400
 401 def _get_result_type(match):
 402     if isinstance(match, models.Book) or isinstance(match, pdcounter_models.BookStub):
 403         type = 'book'
 404     else:
 405         type = match.category
 406     return type
 407
 408
 409 def books_starting_with(prefix):
 410     prefix = prefix.lower()
 411     return models.Book.objects.filter(_word_starts_with('title', prefix))
 412
 413
 414 def find_best_matches(query, user=None):
 415     """ Finds a Book, Tag, BookStub or Author best matching a query.
 416
 417     Returns a with:
 418       - zero elements when nothing is found,
 419       - one element when a best result is found,
 420       - more then one element on multiple exact matches
 421
 422     Raises a ValueError on too short a query.
 423     """
 424
 425     query = query.lower()
 426     if len(query) < 2:
 427         raise ValueError("query must have at least two characters")
 428
 429     result = tuple(_tags_starting_with(query, user))
 430     # remove pdcounter stuff
 431     book_titles = set(match.pretty_title().lower() for match in result
 432                       if isinstance(match, models.Book))
 433     authors = set(match.name.lower() for match in result
 434                   if isinstance(match, models.Tag) and match.category=='author')
 435     result = tuple(res for res in result if not (
 436                  (isinstance(res, pdcounter_models.BookStub) and res.pretty_title().lower() in book_titles)
 437                  or (isinstance(res, pdcounter_models.Author) and res.name.lower() in authors)
 438              ))
 439
 440     exact_matches = tuple(res for res in result if res.name.lower() == query)
 441     if exact_matches:
 442         return exact_matches
 443     else:
 444         return tuple(result)[:1]
 445
 446
 447 def search(request):
 448     tags = request.GET.get('tags', '')
 449     prefix = request.GET.get('q', '')
 450
 451     try:
 452         tag_list = models.Tag.get_tag_list(tags)
 453     except:
 454         tag_list = []
 455
 456     try:
 457         result = find_best_matches(prefix, request.user)
 458     except ValueError:
 459         return render_to_response('catalogue/search_too_short.html', {'tags':tag_list, 'prefix':prefix},
 460             context_instance=RequestContext(request))
 461
 462     if len(result) == 1:
 463         return HttpResponseRedirect(_get_result_link(result[0], tag_list))
 464     elif len(result) > 1:
 465         return render_to_response('catalogue/search_multiple_hits.html',
 466             {'tags':tag_list, 'prefix':prefix, 'results':((x, _get_result_link(x, tag_list), _get_result_type(x)) for x in result)},
 467             context_instance=RequestContext(request))
 468     else:
 469         return render_to_response('catalogue/search_no_hits.html', {'tags':tag_list, 'prefix':prefix},
 470             context_instance=RequestContext(request))
 471
 472
 473 def tags_starting_with(request):
 474     prefix = request.GET.get('q', '')
 475     # Prefix must have at least 2 characters
 476     if len(prefix) < 2:
 477         return HttpResponse('')
 478     tags_list = []
 479     result = ""
 480     for tag in _tags_starting_with(prefix, request.user):
 481         if not tag.name in tags_list:
 482             result += "\n" + tag.name
 483             tags_list.append(tag.name)
 484     return HttpResponse(result)
 485
 486 def json_tags_starting_with(request, callback=None):
 487     # Callback for JSONP
 488     prefix = request.GET.get('q', '')
 489     callback = request.GET.get('callback', '')
 490     # Prefix must have at least 2 characters
 491     if len(prefix) < 2:
 492         return HttpResponse('')
 493     tags_list = []
 494     for tag in _tags_starting_with(prefix, request.user):
 495         if not tag.name in tags_list:
 496             tags_list.append(tag.name)
 497     if request.GET.get('mozhint', ''):
 498         result = [prefix, tags_list]
 499     else:
 500         result = {"matches": tags_list}
 501     return JSONResponse(result, callback)
 502
 503 # ====================
 504 # = Shelf management =
 505 # ====================
 506 @login_required
 507 @cache.never_cache
 508 def user_shelves(request):
 509     shelves = models.Tag.objects.filter(category='set', user=request.user)
 510     new_set_form = forms.NewSetForm()
 511     return render_to_response('catalogue/user_shelves.html', locals(),
 512             context_instance=RequestContext(request))
 513
 514 @cache.never_cache
 515 def book_sets(request, slug):
 516     if not request.user.is_authenticated():
 517         return HttpResponse(_('<p>To maintain your shelves you need to be logged in.</p>'))
 518
 519     book = get_object_or_404(models.Book, slug=slug)
 520     user_sets = models.Tag.objects.filter(category='set', user=request.user)
 521     book_sets = book.tags.filter(category='set', user=request.user)
 522
 523     if request.method == 'POST':
 524         form = forms.ObjectSetsForm(book, request.user, request.POST)
 525         if form.is_valid():
 526             old_shelves = list(book.tags.filter(category='set'))
 527             new_shelves = [models.Tag.objects.get(pk=id) for id in form.cleaned_data['set_ids']]
 528
 529             for shelf in [shelf for shelf in old_shelves if shelf not in new_shelves]:
 530                 shelf.book_count = None
 531                 shelf.save()
 532
 533             for shelf in [shelf for shelf in new_shelves if shelf not in old_shelves]:
 534                 shelf.book_count = None
 535                 shelf.save()
 536
 537             book.tags = new_shelves + list(book.tags.filter(~Q(category='set') | ~Q(user=request.user)))
 538             if request.is_ajax():
 539                 return JSONResponse('{"msg":"'+_("<p>Shelves were sucessfully saved.</p>")+'", "after":"close"}')
 540             else:
 541                 return HttpResponseRedirect('/')
 542     else:
 543         form = forms.ObjectSetsForm(book, request.user)
 544         new_set_form = forms.NewSetForm()
 545
 546     return render_to_response('catalogue/book_sets.html', locals(),
 547         context_instance=RequestContext(request))
 548
 549
 550 @login_required
 551 @require_POST
 552 @cache.never_cache
 553 def remove_from_shelf(request, shelf, book):
 554     book = get_object_or_404(models.Book, slug=book)
 555     shelf = get_object_or_404(models.Tag, slug=shelf, category='set', user=request.user)
 556
 557     if shelf in book.tags:
 558         models.Tag.objects.remove_tag(book, shelf)
 559
 560         shelf.book_count = None
 561         shelf.save()
 562
 563         return HttpResponse(_('Book was successfully removed from the shelf'))
 564     else:
 565         return HttpResponse(_('This book is not on the shelf'))
 566
 567
 568 def collect_books(books):
 569     """
 570     Returns all real books in collection.
 571     """
 572     result = []
 573     for book in books:
 574         if len(book.children.all()) == 0:
 575             result.append(book)
 576         else:
 577             result += collect_books(book.children.all())
 578     return result
 579
 580
 581 @cache.never_cache
 582 def download_shelf(request, slug):
 583     """"
 584     Create a ZIP archive on disk and transmit it in chunks of 8KB,
 585     without loading the whole file into memory. A similar approach can
 586     be used for large dynamic PDF files.
 587     """
 588     shelf = get_object_or_404(models.Tag, slug=slug, category='set')
 589
 590     formats = []
 591     form = forms.DownloadFormatsForm(request.GET)
 592     if form.is_valid():
 593         formats = form.cleaned_data['formats']
 594     if len(formats) == 0:
 595         formats = ['pdf', 'epub', 'odt', 'txt']
 596
 597     # Create a ZIP archive
 598     temp = tempfile.TemporaryFile()
 599     archive = zipfile.ZipFile(temp, 'w')
 600
 601     already = set()
 602     for book in collect_books(models.Book.tagged.with_all(shelf)):
 603         if 'pdf' in formats and book.pdf_file:
 604             filename = book.pdf_file.path
 605             archive.write(filename, str('%s.pdf' % book.slug))
 606         if book.root_ancestor not in already and 'epub' in formats and book.root_ancestor.epub_file:
 607             filename = book.root_ancestor.epub_file.path
 608             archive.write(filename, str('%s.epub' % book.root_ancestor.slug))
 609             already.add(book.root_ancestor)
 610         if 'odt' in formats and book.has_media("odt"):
 611             for file in book.get_media("odt"):
 612                 filename = file.file.path
 613                 archive.write(filename, str('%s.odt' % slughifi(file.name)))
 614         if 'txt' in formats and book.txt_file:
 615             filename = book.txt_file.path
 616             archive.write(filename, str('%s.txt' % book.slug))
 617     archive.close()
 618
 619     response = HttpResponse(content_type='application/zip', mimetype='application/x-zip-compressed')
 620     response['Content-Disposition'] = 'attachment; filename=%s.zip' % slughifi(shelf.name)
 621     response['Content-Length'] = temp.tell()
 622
 623     temp.seek(0)
 624     response.write(temp.read())
 625     return response
 626
 627
 628 @cache.never_cache
 629 def shelf_book_formats(request, shelf):
 630     """"
 631     Returns a list of formats of books in shelf.
 632     """
 633     shelf = get_object_or_404(models.Tag, slug=shelf, category='set')
 634
 635     formats = {'pdf': False, 'epub': False, 'odt': False, 'txt': False}
 636
 637     for book in collect_books(models.Book.tagged.with_all(shelf)):
 638         if book.pdf_file:
 639             formats['pdf'] = True
 640         if book.root_ancestor.epub_file:
 641             formats['epub'] = True
 642         if book.txt_file:
 643             formats['txt'] = True
 644         for format in ('odt',):
 645             if book.has_media(format):
 646                 formats[format] = True
 647
 648     return HttpResponse(LazyEncoder().encode(formats))
 649
 650
 651 @login_required
 652 @require_POST
 653 @cache.never_cache
 654 def new_set(request):
 655     new_set_form = forms.NewSetForm(request.POST)
 656     if new_set_form.is_valid():
 657         new_set = new_set_form.save(request.user)
 658
 659         if request.is_ajax():
 660             return JSONResponse('{"id":"%d", "name":"%s", "msg":"<p>Shelf <strong>%s</strong> was successfully created</p>"}' % (new_set.id, new_set.name, new_set))
 661         else:
 662             return HttpResponseRedirect('/')
 663
 664     return HttpResponseRedirect('/')
 665
 666
 667 @login_required
 668 @require_POST
 669 @cache.never_cache
 670 def delete_shelf(request, slug):
 671     user_set = get_object_or_404(models.Tag, slug=slug, category='set', user=request.user)
 672     user_set.delete()
 673
 674     if request.is_ajax():
 675         return HttpResponse(_('<p>Shelf <strong>%s</strong> was successfully removed</p>') % user_set.name)
 676     else:
 677         return HttpResponseRedirect('/')
 678
 679
 680 # ==================
 681 # = Authentication =
 682 # ==================
 683 @require_POST
 684 @cache.never_cache
 685 def login(request):
 686     form = AuthenticationForm(data=request.POST, prefix='login')
 687     if form.is_valid():
 688         auth.login(request, form.get_user())
 689         response_data = {'success': True, 'errors': {}}
 690     else:
 691         response_data = {'success': False, 'errors': form.errors}
 692     return HttpResponse(LazyEncoder(ensure_ascii=False).encode(response_data))
 693
 694
 695 @require_POST
 696 @cache.never_cache
 697 def register(request):
 698     registration_form = UserCreationForm(request.POST, prefix='registration')
 699     if registration_form.is_valid():
 700         user = registration_form.save()
 701         user = auth.authenticate(
 702             username=registration_form.cleaned_data['username'],
 703             password=registration_form.cleaned_data['password1']
 704         )
 705         auth.login(request, user)
 706         response_data = {'success': True, 'errors': {}}
 707     else:
 708         response_data = {'success': False, 'errors': registration_form.errors}
 709     return HttpResponse(LazyEncoder(ensure_ascii=False).encode(response_data))
 710
 711
 712 @cache.never_cache
 713 def logout_then_redirect(request):
 714     auth.logout(request)
 715     return HttpResponseRedirect(urlquote_plus(request.GET.get('next', '/'), safe='/?='))
 716
 717
 718
 719 # =========
 720 # = Admin =
 721 # =========
 722 @login_required
 723 @staff_required
 724 def import_book(request):
 725     """docstring for import_book"""
 726     book_import_form = forms.BookImportForm(request.POST, request.FILES)
 727     if book_import_form.is_valid():
 728         try:
 729             book_import_form.save()
 730         except:
 731             info = sys.exc_info()
 732             exception = pprint.pformat(info[1])
 733             tb = '\n'.join(traceback.format_tb(info[2]))
 734             return HttpResponse(_("An error occurred: %(exception)s\n\n%(tb)s") % {'exception':exception, 'tb':tb}, mimetype='text/plain')
 735         return HttpResponse(_("Book imported successfully"))
 736     else:
 737         return HttpResponse(_("Error importing file: %r") % book_import_form.errors)
 738
 739
 740
 741 def clock(request):
 742     """ Provides server time for jquery.countdown,
 743     in a format suitable for Date.parse()
 744     """
 745     return HttpResponse(datetime.now().strftime('%Y/%m/%d %H:%M:%S'))
 746
 747
 748 @cache.never_cache
 749 def xmls(request):
 750     """"
 751     Create a zip archive with all XML files.
 752     This should be removed when we have real API.
 753     """
 754     temp = tempfile.TemporaryFile()
 755     archive = zipfile.ZipFile(temp, 'w')
 756
 757     for book in models.Book.objects.all():
 758         archive.write(book.xml_file.path, str('%s.xml' % book.slug))
 759     archive.close()
 760
 761     response = HttpResponse(content_type='application/zip', mimetype='application/x-zip-compressed')
 762     response['Content-Disposition'] = 'attachment; filename=xmls.zip'
 763     response['Content-Length'] = temp.tell()
 764
 765     temp.seek(0)
 766     response.write(temp.read())
 767     return response