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.
12 from django.conf import settings
13 from django.template import RequestContext
14 from django.shortcuts import render_to_response, get_object_or_404
15 from django.http import HttpResponse, HttpResponseRedirect, Http404
16 from django.core.urlresolvers import reverse
17 from django.db.models import Q
18 from django.contrib.auth.decorators import login_required, user_passes_test
19 from django.utils.datastructures import SortedDict
20 from django.views.decorators.http import require_POST
21 from django.contrib import auth
22 from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
23 from django.utils import simplejson
24 from django.utils.functional import Promise
25 from django.utils.encoding import force_unicode
26 from django.utils.http import urlquote_plus
27 from django.views.decorators import cache
28 from django.utils.translation import ugettext as _
29 from django.views.generic.list_detail import object_list
31 from catalogue import models
32 from catalogue import forms
33 from catalogue.utils import split_tags
34 from newtagging import views as newtagging_views
37 staff_required = user_passes_test(lambda user: user.is_staff)
40 class LazyEncoder(simplejson.JSONEncoder):
41 def default(self, obj):
42 if isinstance(obj, Promise):
43 return force_unicode(obj)
47 def main_page(request):
48 if request.user.is_authenticated():
49 shelves = models.Tag.objects.filter(category='set', user=request.user)
50 new_set_form = forms.NewSetForm()
51 extra_where = "NOT catalogue_tag.category = 'set'"
52 tags = models.Tag.objects.usage_for_model(models.Book, counts=True, extra={'where': [extra_where]})
53 fragment_tags = models.Tag.objects.usage_for_model(models.Fragment, counts=True,
54 extra={'where': ["catalogue_tag.category = 'theme'"] + [extra_where]})
55 categories = split_tags(tags)
57 form = forms.SearchForm()
58 return render_to_response('catalogue/main_page.html', locals(),
59 context_instance=RequestContext(request))
62 def book_list(request):
63 books = models.Book.objects.all()
64 form = forms.SearchForm()
66 books_by_first_letter = SortedDict()
68 books_by_first_letter.setdefault(book.title[0], []).append(book)
70 return render_to_response('catalogue/book_list.html', locals(),
71 context_instance=RequestContext(request))
74 def tagged_object_list(request, tags=''):
75 # Prevent DoS attacks on our database
76 if len(tags.split('/')) > 6:
80 tags = models.Tag.get_tag_list(tags)
81 except models.Tag.DoesNotExist:
84 if len([tag for tag in tags if tag.category == 'book']):
87 theme_is_set = [tag for tag in tags if tag.category == 'theme']
88 shelf_is_set = len(tags) == 1 and tags[0].category == 'set'
89 my_shelf_is_set = shelf_is_set and request.user.is_authenticated() and request.user == tags[0].user
91 objects = only_author = pd_counter = categories = None
94 shelf_tags = [tag for tag in tags if tag.category == 'set']
95 fragment_tags = [tag for tag in tags if tag.category != 'set']
96 fragments = models.Fragment.tagged.with_all(fragment_tags)
99 books = models.Book.tagged.with_all(shelf_tags).order_by()
100 l_tags = [models.Tag.objects.get(slug = 'l-' + book.slug) for book in books]
101 fragments = models.Fragment.tagged.with_any(l_tags, fragments)
103 related_tags = models.Tag.objects.usage_for_queryset(fragments, counts=True,
104 extra={'where': ["catalogue_tag.category != 'book'"]})
105 related_tags = (tag for tag in related_tags if tag not in fragment_tags)
106 categories = split_tags(related_tags)
110 books = models.Book.tagged.with_all(tags).order_by()
111 l_tags = [models.Tag.objects.get(slug = 'l-' + book.slug) for book in books]
112 book_keys = [book.pk for book in books]
113 related_tags = models.Tag.objects.usage_for_queryset(books, counts=True,
114 extra={'where': ["catalogue_tag.category NOT IN ('set', 'book', 'theme')"]})
115 related_tags = (tag for tag in related_tags if tag not in tags)
116 categories = split_tags(related_tags)
118 fragments = models.Fragment.tagged.with_any(l_tags)
119 categories['theme'] = models.Tag.objects.usage_for_queryset(fragments, counts=True,
120 extra={'where': ["catalogue_tag.category = 'theme'"]})
122 books = books.exclude(parent__in = book_keys)
126 only_author = len(tags) == 1 and tags[0].category == 'author'
127 pd_counter = only_author and tags[0].goes_to_pd()
128 objects = models.Book.objects.none()
133 template_name='catalogue/tagged_object_list.html',
135 'categories': categories,
136 'shelf_is_set': shelf_is_set,
137 'only_author': only_author,
138 'pd_counter': pd_counter,
139 'user_is_owner': my_shelf_is_set,
140 'formats_form': forms.DownloadFormatsForm(),
147 def book_fragments(request, book_slug, theme_slug):
148 book = get_object_or_404(models.Book, slug=book_slug)
149 book_tag = get_object_or_404(models.Tag, slug='l-' + book_slug)
150 theme = get_object_or_404(models.Tag, slug=theme_slug)
151 fragments = models.Fragment.tagged.with_all([book_tag, theme])
153 form = forms.SearchForm()
154 return render_to_response('catalogue/book_fragments.html', locals(),
155 context_instance=RequestContext(request))
158 def book_detail(request, slug):
160 book = models.Book.objects.get(slug=slug)
161 except models.Book.DoesNotExist:
162 return book_stub_detail(request, slug)
164 book_tag = get_object_or_404(models.Tag, slug = 'l-' + slug)
165 tags = list(book.tags.filter(~Q(category='set')))
166 categories = split_tags(tags)
167 book_children = book.children.all().order_by('parent_number')
168 extra_where = "catalogue_tag.category = 'theme'"
169 book_themes = models.Tag.objects.related_for_model(book_tag, models.Fragment, counts=True, extra={'where': [extra_where]})
170 extra_info = book.get_extra_info_value()
172 form = forms.SearchForm()
173 return render_to_response('catalogue/book_detail.html', locals(),
174 context_instance=RequestContext(request))
177 def book_stub_detail(request, slug):
178 book = get_object_or_404(models.BookStub, slug=slug)
180 form = forms.SearchForm()
182 return render_to_response('catalogue/book_stub_detail.html', locals(),
183 context_instance=RequestContext(request))
186 def book_text(request, slug):
187 book = get_object_or_404(models.Book, slug=slug)
189 for fragment in book.fragments.all():
190 for theme in fragment.tags.filter(category='theme'):
191 book_themes.setdefault(theme, []).append(fragment)
193 book_themes = book_themes.items()
194 book_themes.sort(key=lambda s: s[0].sort_key)
195 return render_to_response('catalogue/book_text.html', locals(),
196 context_instance=RequestContext(request))
203 def _no_diacritics_regexp(query):
204 """ returns a regexp for searching for a query without diacritics
206 should be locale-aware """
207 names = {'a':u'ą', 'c':u'ć', 'e':u'ę', 'l': u'ł', 'n':u'ń', 'o':u'ó', 's':u'ś', 'z':u'ź|ż'}
210 return "(%s|%s)" % (l, names[l])
211 return re.sub('[%s]'%(''.join(names.keys())), repl, query)
213 def _word_starts_with(name, prefix):
214 """returns a Q object getting models having `name` contain a word
215 starting with `prefix`
218 if settings.DATABASE_ENGINE in ('mysql', 'postgresql_psycopg2', 'postgresql'):
219 prefix = _no_diacritics_regexp(re.escape(prefix))
220 # we could use a [[:<:]] (word start),
221 # but we want both `xy` and `(xy` to catch `(xyz)`
222 kwargs['%s__iregex' % name] = u"(^|[^[:alpha:]])%s" % prefix
224 # don't know how to do a generic regex
225 # checking for simple icontain instead
226 kwargs['%s__icontains' % name] = prefix
230 def _tags_exact_matches(prefix, user):
231 book_stubs = models.BookStub.objects.filter(title__iexact = prefix)
232 books = models.Book.objects.filter(title__iexact = prefix)
233 book_stubs = filter(lambda x: x not in books, book_stubs)
234 tags = models.Tag.objects.filter(name__iexact = prefix)
235 if user.is_authenticated():
236 tags = tags.filter(~Q(category='book') & (~Q(category='set') | Q(user=user)))
238 tags = tags.filter(~Q(category='book') & ~Q(category='set'))
240 return list(books) + list(tags) + list(book_stubs)
243 def _tags_starting_with(prefix, user):
244 book_stubs = models.BookStub.objects.filter(_word_starts_with('title', prefix))
245 books = models.Book.objects.filter(_word_starts_with('title', prefix))
246 book_stubs = filter(lambda x: x not in books, book_stubs)
247 tags = models.Tag.objects.filter(_word_starts_with('name', prefix))
248 if user.is_authenticated():
249 tags = tags.filter(~Q(category='book') & (~Q(category='set') | Q(user=user)))
251 tags = tags.filter(~Q(category='book') & ~Q(category='set'))
253 return list(books) + list(tags) + list(book_stubs)
257 def _get_result_link(match, tag_list):
258 if isinstance(match, models.Book) or isinstance(match, models.BookStub):
259 return match.get_absolute_url()
261 return reverse('catalogue.views.tagged_object_list',
262 kwargs={'tags': '/'.join(tag.slug for tag in tag_list + [match])}
265 def _get_result_type(match):
266 if isinstance(match, models.Book) or isinstance(match, models.BookStub):
269 type = match.category
270 return dict(models.TAG_CATEGORIES)[type]
275 tags = request.GET.get('tags', '')
276 prefix = request.GET.get('q', '')
279 tag_list = models.Tag.get_tag_list(tags)
283 # Prefix must have at least 2 characters
285 return render_to_response('catalogue/search_too_short.html', {'tags':tag_list, 'prefix':prefix},
286 context_instance=RequestContext(request))
288 result = _tags_exact_matches(prefix, request.user)
291 # multiple exact matches
292 return render_to_response('catalogue/search_multiple_hits.html',
293 {'tags':tag_list, 'prefix':prefix, 'results':((x, _get_result_link(x, tag_list), _get_result_type(x)) for x in result)},
294 context_instance=RequestContext(request))
298 result = _tags_starting_with(prefix, request.user)
301 return HttpResponseRedirect(_get_result_link(result[0], tag_list))
303 return render_to_response('catalogue/search_no_hits.html', {'tags':tag_list, 'prefix':prefix},
304 context_instance=RequestContext(request))
307 def tags_starting_with(request):
308 prefix = request.GET.get('q', '')
309 # Prefix must have at least 2 characters
311 return HttpResponse('')
313 return HttpResponse('\n'.join(tag.name for tag in _tags_starting_with(prefix, request.user)))
316 # ====================
317 # = Shelf management =
318 # ====================
321 def user_shelves(request):
322 shelves = models.Tag.objects.filter(category='set', user=request.user)
323 new_set_form = forms.NewSetForm()
324 return render_to_response('catalogue/user_shelves.html', locals(),
325 context_instance=RequestContext(request))
328 def book_sets(request, slug):
329 book = get_object_or_404(models.Book, slug=slug)
330 user_sets = models.Tag.objects.filter(category='set', user=request.user)
331 book_sets = book.tags.filter(category='set', user=request.user)
333 if not request.user.is_authenticated():
334 return HttpResponse(_('<p>To maintain your shelves you need to be logged in.</p>'))
336 if request.method == 'POST':
337 form = forms.ObjectSetsForm(book, request.user, request.POST)
339 old_shelves = list(book.tags.filter(category='set'))
340 new_shelves = [models.Tag.objects.get(pk=id) for id in form.cleaned_data['set_ids']]
342 for shelf in [shelf for shelf in old_shelves if shelf not in new_shelves]:
343 shelf.book_count -= 1
346 for shelf in [shelf for shelf in new_shelves if shelf not in old_shelves]:
347 shelf.book_count += 1
350 book.tags = new_shelves + list(book.tags.filter(~Q(category='set') | ~Q(user=request.user)))
351 if request.is_ajax():
352 return HttpResponse(_('<p>Shelves were sucessfully saved.</p>'))
354 return HttpResponseRedirect('/')
356 form = forms.ObjectSetsForm(book, request.user)
357 new_set_form = forms.NewSetForm()
359 return render_to_response('catalogue/book_sets.html', locals(),
360 context_instance=RequestContext(request))
366 def remove_from_shelf(request, shelf, book):
367 book = get_object_or_404(models.Book, slug=book)
368 shelf = get_object_or_404(models.Tag, slug=shelf, category='set', user=request.user)
370 if shelf in book.tags:
371 models.Tag.objects.remove_tag(book, shelf)
373 shelf.book_count -= 1
376 return HttpResponse(_('Book was successfully removed from the shelf'))
378 return HttpResponse(_('This book is not on the shelf'))
381 def collect_books(books):
383 Returns all real books in collection.
387 if len(book.children.all()) == 0:
390 result += collect_books(book.children.all())
395 def download_shelf(request, slug):
397 Create a ZIP archive on disk and transmit it in chunks of 8KB,
398 without loading the whole file into memory. A similar approach can
399 be used for large dynamic PDF files.
401 shelf = get_object_or_404(models.Tag, slug=slug, category='set')
404 form = forms.DownloadFormatsForm(request.GET)
406 formats = form.cleaned_data['formats']
407 if len(formats) == 0:
408 formats = ['pdf', 'odt', 'txt', 'mp3', 'ogg']
410 # Create a ZIP archive
411 temp = tempfile.TemporaryFile()
412 archive = zipfile.ZipFile(temp, 'w')
414 for book in collect_books(models.Book.tagged.with_all(shelf)):
415 if 'pdf' in formats and book.pdf_file:
416 filename = book.pdf_file.path
417 archive.write(filename, str('%s.pdf' % book.slug))
418 if 'odt' in formats and book.odt_file:
419 filename = book.odt_file.path
420 archive.write(filename, str('%s.odt' % book.slug))
421 if 'txt' in formats and book.txt_file:
422 filename = book.txt_file.path
423 archive.write(filename, str('%s.txt' % book.slug))
424 if 'mp3' in formats and book.mp3_file:
425 filename = book.mp3_file.path
426 archive.write(filename, str('%s.mp3' % book.slug))
427 if 'ogg' in formats and book.ogg_file:
428 filename = book.ogg_file.path
429 archive.write(filename, str('%s.ogg' % book.slug))
432 response = HttpResponse(content_type='application/zip', mimetype='application/x-zip-compressed')
433 response['Content-Disposition'] = 'attachment; filename=%s.zip' % shelf.sort_key
434 response['Content-Length'] = temp.tell()
437 response.write(temp.read())
442 def shelf_book_formats(request, shelf):
444 Returns a list of formats of books in shelf.
446 shelf = get_object_or_404(models.Tag, slug=shelf, category='set')
448 formats = {'pdf': False, 'odt': False, 'txt': False, 'mp3': False, 'ogg': False}
450 for book in collect_books(models.Book.tagged.with_all(shelf)):
452 formats['pdf'] = True
454 formats['odt'] = True
456 formats['txt'] = True
458 formats['mp3'] = True
460 formats['ogg'] = True
462 return HttpResponse(LazyEncoder().encode(formats))
468 def new_set(request):
469 new_set_form = forms.NewSetForm(request.POST)
470 if new_set_form.is_valid():
471 new_set = new_set_form.save(request.user)
473 if request.is_ajax():
474 return HttpResponse(_('<p>Shelf <strong>%s</strong> was successfully created</p>') % new_set)
476 return HttpResponseRedirect('/')
478 return HttpResponseRedirect('/')
484 def delete_shelf(request, slug):
485 user_set = get_object_or_404(models.Tag, slug=slug, category='set', user=request.user)
488 if request.is_ajax():
489 return HttpResponse(_('<p>Shelf <strong>%s</strong> was successfully removed</p>') % user_set.name)
491 return HttpResponseRedirect('/')
500 form = AuthenticationForm(data=request.POST, prefix='login')
502 auth.login(request, form.get_user())
503 response_data = {'success': True, 'errors': {}}
505 response_data = {'success': False, 'errors': form.errors}
506 return HttpResponse(LazyEncoder(ensure_ascii=False).encode(response_data))
511 def register(request):
512 registration_form = UserCreationForm(request.POST, prefix='registration')
513 if registration_form.is_valid():
514 user = registration_form.save()
515 user = auth.authenticate(
516 username=registration_form.cleaned_data['username'],
517 password=registration_form.cleaned_data['password1']
519 auth.login(request, user)
520 response_data = {'success': True, 'errors': {}}
522 response_data = {'success': False, 'errors': registration_form.errors}
523 return HttpResponse(LazyEncoder(ensure_ascii=False).encode(response_data))
527 def logout_then_redirect(request):
529 return HttpResponseRedirect(urlquote_plus(request.GET.get('next', '/'), safe='/?='))
538 def import_book(request):
539 """docstring for import_book"""
540 book_import_form = forms.BookImportForm(request.POST, request.FILES)
541 if book_import_form.is_valid():
543 book_import_form.save()
545 info = sys.exc_info()
546 exception = pprint.pformat(info[1])
547 tb = '\n'.join(traceback.format_tb(info[2]))
548 _('Today is %(month)s, %(day)s.') % {'month': m, 'day': d}
549 return HttpResponse(_("An error occurred: %(exception)s\n\n%(tb)s") % {'exception':exception, 'tb':tb}, mimetype='text/plain')
550 return HttpResponse(_("Book imported successfully"))
552 return HttpResponse(_("Error importing file: %r") % book_import_form.errors)
557 """ Provides server time for jquery.countdown,
558 in a format suitable for Date.parse()
560 from datetime import datetime
561 return HttpResponse(datetime.now().strftime('%Y/%m/%d %H:%M:%S'))