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