13a7da4ffcaa62d5d1b529884a99f6e074510b3d
[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
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     result = ""   
495     for tag in _tags_starting_with(prefix, request.user):
496         if not tag.name in tags_list:
497             result += "\n" + tag.name
498             tags_list.append(tag.name)
499     dict_result = {"matches": tags_list}
500     return JSONResponse(dict_result, callback)
501
502 # ====================
503 # = Shelf management =
504 # ====================
505 @login_required
506 @cache.never_cache
507 def user_shelves(request):
508     shelves = models.Tag.objects.filter(category='set', user=request.user)
509     new_set_form = forms.NewSetForm()
510     return render_to_response('catalogue/user_shelves.html', locals(),
511             context_instance=RequestContext(request))
512
513 @cache.never_cache
514 def book_sets(request, slug):
515     if not request.user.is_authenticated():
516         return HttpResponse(_('<p>To maintain your shelves you need to be logged in.</p>'))
517
518     book = get_object_or_404(models.Book, slug=slug)
519     user_sets = models.Tag.objects.filter(category='set', user=request.user)
520     book_sets = book.tags.filter(category='set', user=request.user)
521
522     if request.method == 'POST':
523         form = forms.ObjectSetsForm(book, request.user, request.POST)
524         if form.is_valid():
525             old_shelves = list(book.tags.filter(category='set'))
526             new_shelves = [models.Tag.objects.get(pk=id) for id in form.cleaned_data['set_ids']]
527
528             for shelf in [shelf for shelf in old_shelves if shelf not in new_shelves]:
529                 shelf.book_count = None
530                 shelf.save()
531
532             for shelf in [shelf for shelf in new_shelves if shelf not in old_shelves]:
533                 shelf.book_count = None
534                 shelf.save()
535
536             book.tags = new_shelves + list(book.tags.filter(~Q(category='set') | ~Q(user=request.user)))
537             if request.is_ajax():
538                 return JSONResponse('{"msg":"'+_("<p>Shelves were sucessfully saved.</p>")+'", "after":"close"}')
539             else:
540                 return HttpResponseRedirect('/')
541     else:
542         form = forms.ObjectSetsForm(book, request.user)
543         new_set_form = forms.NewSetForm()
544
545     return render_to_response('catalogue/book_sets.html', locals(),
546         context_instance=RequestContext(request))
547
548
549 @login_required
550 @require_POST
551 @cache.never_cache
552 def remove_from_shelf(request, shelf, book):
553     book = get_object_or_404(models.Book, slug=book)
554     shelf = get_object_or_404(models.Tag, slug=shelf, category='set', user=request.user)
555
556     if shelf in book.tags:
557         models.Tag.objects.remove_tag(book, shelf)
558
559         shelf.book_count = None
560         shelf.save()
561
562         return HttpResponse(_('Book was successfully removed from the shelf'))
563     else:
564         return HttpResponse(_('This book is not on the shelf'))
565
566
567 def collect_books(books):
568     """
569     Returns all real books in collection.
570     """
571     result = []
572     for book in books:
573         if len(book.children.all()) == 0:
574             result.append(book)
575         else:
576             result += collect_books(book.children.all())
577     return result
578
579
580 @cache.never_cache
581 def download_shelf(request, slug):
582     """"
583     Create a ZIP archive on disk and transmit it in chunks of 8KB,
584     without loading the whole file into memory. A similar approach can
585     be used for large dynamic PDF files.
586     """
587     shelf = get_object_or_404(models.Tag, slug=slug, category='set')
588
589     formats = []
590     form = forms.DownloadFormatsForm(request.GET)
591     if form.is_valid():
592         formats = form.cleaned_data['formats']
593     if len(formats) == 0:
594         formats = ['pdf', 'epub', 'odt', 'txt', 'mp3', 'ogg', 'daisy']
595
596     # Create a ZIP archive
597     temp = tempfile.TemporaryFile()
598     archive = zipfile.ZipFile(temp, 'w')
599
600     already = set()
601     for book in collect_books(models.Book.tagged.with_all(shelf)):
602         if 'pdf' in formats and book.pdf_file:
603             filename = book.pdf_file.path
604             archive.write(filename, str('%s.pdf' % book.slug))
605         if book.root_ancestor not in already and 'epub' in formats and book.root_ancestor.epub_file:
606             filename = book.root_ancestor.epub_file.path
607             archive.write(filename, str('%s.epub' % book.root_ancestor.slug))
608             already.add(book.root_ancestor)
609         if 'odt' in formats and book.has_media("odt"):
610             for file in book.get_media("odt"):
611                 filename = file.file.path
612                 archive.write(filename, str('%s.odt' % slughifi(file.name)))
613         if 'txt' in formats and book.txt_file:
614             filename = book.txt_file.path
615             archive.write(filename, str('%s.txt' % book.slug))
616         if 'mp3' in formats and book.has_media("mp3"):
617             for file in book.get_media("mp3"):
618                 filename = file.file.path
619                 archive.write(filename, str('%s.mp3' % slughifi(file.name)))
620         if 'ogg' in formats and book.has_media("ogg"):
621             for file in book.get_media("ogg"):
622                 filename = file.file.path
623                 archive.write(filename, str('%s.ogg' % slughifi(file.name)))
624         if 'daisy' in formats and book.has_media("daisy"):
625             for file in book.get_media("daisy"):
626                 filename = file.file.path
627                 archive.write(filename, str('%s.daisy' % slughifi(file.name)))
628     archive.close()
629
630     response = HttpResponse(content_type='application/zip', mimetype='application/x-zip-compressed')
631     response['Content-Disposition'] = 'attachment; filename=%s.zip' % slughifi(shelf.name)
632     response['Content-Length'] = temp.tell()
633
634     temp.seek(0)
635     response.write(temp.read())
636     return response
637
638
639 @cache.never_cache
640 def shelf_book_formats(request, shelf):
641     """"
642     Returns a list of formats of books in shelf.
643     """
644     shelf = get_object_or_404(models.Tag, slug=shelf, category='set')
645
646     formats = {'pdf': False, 'epub': False, 'odt': False, 'txt': False, 'mp3': False, 'ogg': False, 'daisy': False}
647
648     for book in collect_books(models.Book.tagged.with_all(shelf)):
649         if book.pdf_file:
650             formats['pdf'] = True
651         if book.root_ancestor.epub_file:
652             formats['epub'] = True
653         if book.txt_file:
654             formats['txt'] = True
655         for format in ('odt', 'mp3', 'ogg'):
656             if not formats[format] and book.has_media(format):
657                 formats[format] = True
658
659     return HttpResponse(LazyEncoder().encode(formats))
660
661
662 @login_required
663 @require_POST
664 @cache.never_cache
665 def new_set(request):
666     new_set_form = forms.NewSetForm(request.POST)
667     if new_set_form.is_valid():
668         new_set = new_set_form.save(request.user)
669
670         if request.is_ajax():
671             return JSONResponse('{"id":"%d", "name":"%s", "msg":"<p>Shelf <strong>%s</strong> was successfully created</p>"}' % (new_set.id, new_set.name, new_set))
672         else:
673             return HttpResponseRedirect('/')
674
675     return HttpResponseRedirect('/')
676
677
678 @login_required
679 @require_POST
680 @cache.never_cache
681 def delete_shelf(request, slug):
682     user_set = get_object_or_404(models.Tag, slug=slug, category='set', user=request.user)
683     user_set.delete()
684
685     if request.is_ajax():
686         return HttpResponse(_('<p>Shelf <strong>%s</strong> was successfully removed</p>') % user_set.name)
687     else:
688         return HttpResponseRedirect('/')
689
690
691 # ==================
692 # = Authentication =
693 # ==================
694 @require_POST
695 @cache.never_cache
696 def login(request):
697     form = AuthenticationForm(data=request.POST, prefix='login')
698     if form.is_valid():
699         auth.login(request, form.get_user())
700         response_data = {'success': True, 'errors': {}}
701     else:
702         response_data = {'success': False, 'errors': form.errors}
703     return HttpResponse(LazyEncoder(ensure_ascii=False).encode(response_data))
704
705
706 @require_POST
707 @cache.never_cache
708 def register(request):
709     registration_form = UserCreationForm(request.POST, prefix='registration')
710     if registration_form.is_valid():
711         user = registration_form.save()
712         user = auth.authenticate(
713             username=registration_form.cleaned_data['username'],
714             password=registration_form.cleaned_data['password1']
715         )
716         auth.login(request, user)
717         response_data = {'success': True, 'errors': {}}
718     else:
719         response_data = {'success': False, 'errors': registration_form.errors}
720     return HttpResponse(LazyEncoder(ensure_ascii=False).encode(response_data))
721
722
723 @cache.never_cache
724 def logout_then_redirect(request):
725     auth.logout(request)
726     return HttpResponseRedirect(urlquote_plus(request.GET.get('next', '/'), safe='/?='))
727
728
729
730 # =========
731 # = Admin =
732 # =========
733 @login_required
734 @staff_required
735 def import_book(request):
736     """docstring for import_book"""
737     book_import_form = forms.BookImportForm(request.POST, request.FILES)
738     if book_import_form.is_valid():
739         try:
740             book_import_form.save()
741         except:
742             info = sys.exc_info()
743             exception = pprint.pformat(info[1])
744             tb = '\n'.join(traceback.format_tb(info[2]))
745             return HttpResponse(_("An error occurred: %(exception)s\n\n%(tb)s") % {'exception':exception, 'tb':tb}, mimetype='text/plain')
746         return HttpResponse(_("Book imported successfully"))
747     else:
748         return HttpResponse(_("Error importing file: %r") % book_import_form.errors)
749
750
751
752 def clock(request):
753     """ Provides server time for jquery.countdown,
754     in a format suitable for Date.parse()
755     """
756     return HttpResponse(datetime.now().strftime('%Y/%m/%d %H:%M:%S'))
757
758
759 @cache.never_cache
760 def xmls(request):
761     """"
762     Create a zip archive with all XML files.
763     This should be removed when we have real API.
764     """
765     temp = tempfile.TemporaryFile()
766     archive = zipfile.ZipFile(temp, 'w')
767
768     for book in models.Book.objects.all():
769         archive.write(book.xml_file.path, str('%s.xml' % book.slug))
770     archive.close()
771
772     response = HttpResponse(content_type='application/zip', mimetype='application/x-zip-compressed')
773     response['Content-Disposition'] = 'attachment; filename=xmls.zip'
774     response['Content-Length'] = temp.tell()
775
776     temp.seek(0)
777     response.write(temp.read())
778     return response