changes from server
[redakcja.git] / apps / catalogue / views.py
1 from datetime import datetime, date, timedelta
2 import logging
3 import os
4 from StringIO import StringIO
5 from urllib import unquote
6 from urlparse import urlsplit, urlunsplit
7
8 from django.conf import settings
9 from django.contrib import auth
10 from django.contrib.auth.models import User
11 from django.contrib.auth.decorators import login_required, permission_required
12 from django.core.urlresolvers import reverse
13 from django.db.models import Count, Q
14 from django.db import transaction
15 from django import http
16 from django.http import Http404, HttpResponse, HttpResponseForbidden
17 from django.shortcuts import get_object_or_404, render, render_to_response
18 from django.utils.encoding import iri_to_uri
19 from django.utils.http import urlquote_plus
20 from django.utils.translation import ugettext_lazy as _
21 from django.views.decorators.http import require_POST
22 from django.template import RequestContext
23
24 from apiclient import NotAuthorizedError
25 from catalogue import forms
26 from catalogue import helpers
27 from catalogue.helpers import active_tab
28 from catalogue.models import Book, Chunk, BookPublishRecord, ChunkPublishRecord, Project
29 from fileupload.views import UploadView
30
31 #
32 # Quick hack around caching problems, TODO: use ETags
33 #
34 from django.views.decorators.cache import never_cache
35
36 logger = logging.getLogger("fnp.catalogue")
37
38
39 @active_tab('all')
40 @never_cache
41 def document_list(request):
42     return render(request, 'catalogue/document_list.html')
43
44
45 @never_cache
46 def user(request, username):
47     user = get_object_or_404(User, username=username)
48     return render(request, 'catalogue/user_page.html', {"viewed_user": user})
49
50
51 @login_required
52 @active_tab('my')
53 @never_cache
54 def my(request):
55     return render(request, 'catalogue/my_page.html', {
56         'last_books': sorted(request.session.get("wiki_last_books", {}).items(),
57                         key=lambda x: x[1]['time'], reverse=True),
58
59         "logout_to": '/',
60         })
61
62
63 @active_tab('users')
64 def users(request):
65     return render(request, 'catalogue/user_list.html', {
66         'users': User.objects.all().annotate(count=Count('chunk')).order_by(
67             '-count', 'last_name', 'first_name'),
68     })
69
70
71 @active_tab('activity')
72 def activity(request, isodate=None):
73     today = date.today()
74     try:
75         day = helpers.parse_isodate(isodate)
76     except ValueError:
77         day = today
78
79     if day > today:
80         raise Http404
81     if day != today:
82         next_day = day + timedelta(1)
83     prev_day = day - timedelta(1)
84
85     return render(request, 'catalogue/activity.html', locals())
86
87
88 @never_cache
89 def logout_then_redirect(request):
90     auth.logout(request)
91     return http.HttpResponseRedirect(urlquote_plus(request.GET.get('next', '/'), safe='/?='))
92
93
94 @permission_required('catalogue.add_book')
95 @active_tab('create')
96 def create_missing(request, slug=None):
97     if slug is None:
98         slug = ''
99     slug = slug.replace(' ', '-')
100
101     if request.method == "POST":
102         form = forms.DocumentCreateForm(request.POST, request.FILES)
103         if form.is_valid():
104             
105             if request.user.is_authenticated():
106                 creator = request.user
107             else:
108                 creator = None
109             book = Book.create(
110                 text=form.cleaned_data['text'],
111                 creator=creator,
112                 slug=form.cleaned_data['slug'],
113                 title=form.cleaned_data['title'],
114                 gallery=form.cleaned_data['gallery'],
115             )
116
117             return http.HttpResponseRedirect(reverse("catalogue_book", args=[book.slug]))
118     else:
119         form = forms.DocumentCreateForm(initial={
120                 "slug": slug,
121                 "title": slug.replace('-', ' ').title(),
122                 "gallery": slug,
123         })
124
125     return render(request, "catalogue/document_create_missing.html", {
126         "slug": slug,
127         "form": form,
128
129         "logout_to": '/',
130     })
131
132
133 @permission_required('catalogue.add_book')
134 @active_tab('upload')
135 def upload(request):
136     if request.method == "POST":
137         form = forms.DocumentsUploadForm(request.POST, request.FILES)
138         if form.is_valid():
139             import slughifi
140
141             if request.user.is_authenticated():
142                 creator = request.user
143             else:
144                 creator = None
145
146             zip = form.cleaned_data['zip']
147             skipped_list = []
148             ok_list = []
149             error_list = []
150             slugs = {}
151             existing = [book.slug for book in Book.objects.all()]
152             for filename in zip.namelist():
153                 if filename[-1] == '/':
154                     continue
155                 title = os.path.basename(filename)[:-4]
156                 slug = slughifi(title)
157                 if not (slug and filename.endswith('.xml')):
158                     skipped_list.append(filename)
159                 elif slug in slugs:
160                     error_list.append((filename, slug, _('Slug already used for %s' % slugs[slug])))
161                 elif slug in existing:
162                     error_list.append((filename, slug, _('Slug already used in repository.')))
163                 else:
164                     try:
165                         zip.read(filename).decode('utf-8') # test read
166                         ok_list.append((filename, slug, title))
167                     except UnicodeDecodeError:
168                         error_list.append((filename, title, _('File should be UTF-8 encoded.')))
169                     slugs[slug] = filename
170
171             if not error_list:
172                 for filename, slug, title in ok_list:
173                     book = Book.create(
174                         text=zip.read(filename).decode('utf-8'),
175                         creator=creator,
176                         slug=slug,
177                         title=title,
178                     )
179
180             return render(request, "catalogue/document_upload.html", {
181                 "form": form,
182                 "ok_list": ok_list,
183                 "skipped_list": skipped_list,
184                 "error_list": error_list,
185
186                 "logout_to": '/',
187             })
188     else:
189         form = forms.DocumentsUploadForm()
190
191     return render(request, "catalogue/document_upload.html", {
192         "form": form,
193
194         "logout_to": '/',
195     })
196
197
198 @never_cache
199 def book_xml(request, slug):
200     book = get_object_or_404(Book, slug=slug)
201     if not book.accessible(request):
202         return HttpResponseForbidden("Not authorized.")
203     xml = book.materialize()
204
205     response = http.HttpResponse(xml, content_type='application/xml', mimetype='application/wl+xml')
206     response['Content-Disposition'] = 'attachment; filename=%s.xml' % slug
207     return response
208
209
210 @never_cache
211 def book_txt(request, slug):
212     book = get_object_or_404(Book, slug=slug)
213     if not book.accessible(request):
214         return HttpResponseForbidden("Not authorized.")
215
216     doc = book.wldocument()
217     text = doc.as_text().get_string()
218     response = http.HttpResponse(text, content_type='text/plain', mimetype='text/plain')
219     response['Content-Disposition'] = 'attachment; filename=%s.txt' % slug
220     return response
221
222
223 @never_cache
224 def book_html(request, slug):
225     book = get_object_or_404(Book, slug=slug)
226     if not book.accessible(request):
227         return HttpResponseForbidden("Not authorized.")
228
229     doc = book.wldocument(parse_dublincore=False)
230     html = doc.as_html()
231
232     html = html.get_string() if html is not None else ''
233     # response = http.HttpResponse(html, content_type='text/html', mimetype='text/html')
234     # return response
235     # book_themes = {}
236     # for fragment in book.fragments.all().iterator():
237     #     for theme in fragment.tags.filter(category='theme').iterator():
238     #         book_themes.setdefault(theme, []).append(fragment)
239
240     # book_themes = book_themes.items()
241     # book_themes.sort(key=lambda s: s[0].sort_key)
242     return render_to_response('catalogue/book_text.html', locals(),
243         context_instance=RequestContext(request))
244
245
246 @never_cache
247 def book_pdf(request, slug):
248     book = get_object_or_404(Book, slug=slug)
249     if not book.accessible(request):
250         return HttpResponseForbidden("Not authorized.")
251
252     # TODO: move to celery
253     doc = book.wldocument()
254     # TODO: error handling
255     pdf_file = doc.as_pdf(cover=True, ilustr_path=os.path.join(settings.MEDIA_ROOT, settings.IMAGE_DIR, book.gallery))
256     from catalogue.ebook_utils import serve_file
257     return serve_file(pdf_file.get_filename(),
258                 book.slug + '.pdf', 'application/pdf')
259
260
261 @never_cache
262 def book_epub(request, slug):
263     book = get_object_or_404(Book, slug=slug)
264     if not book.accessible(request):
265         return HttpResponseForbidden("Not authorized.")
266
267     # TODO: move to celery
268     doc = book.wldocument()
269     # TODO: error handling
270     epub = doc.as_epub().get_string()
271     response = HttpResponse(mimetype='application/epub+zip')
272     response['Content-Disposition'] = 'attachment; filename=%s' % book.slug + '.epub'
273     response.write(epub)
274     return response
275
276
277 @never_cache
278 def revision(request, slug, chunk=None):
279     try:
280         doc = Chunk.get(slug, chunk)
281     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
282         raise Http404
283     if not doc.book.accessible(request):
284         return HttpResponseForbidden("Not authorized.")
285     return http.HttpResponse(str(doc.revision()))
286
287
288 def book(request, slug):
289     book = get_object_or_404(Book, slug=slug)
290     if not book.accessible(request):
291         return HttpResponseForbidden("Not authorized.")
292
293     if request.user.has_perm('catalogue.change_book'):
294         if request.method == "POST":
295             form = forms.BookForm(request.POST, instance=book)
296             if form.is_valid():
297                 form.save()
298                 return http.HttpResponseRedirect(book.get_absolute_url())
299         else:
300             form = forms.BookForm(instance=book)
301         editable = True
302     else:
303         form = forms.ReadonlyBookForm(instance=book)
304         editable = False
305
306     publish_error = book.publishable_error()
307     publishable = publish_error is None
308
309     return render(request, "catalogue/book_detail.html", {
310         "book": book,
311         "publishable": publishable,
312         "publishable_error": publish_error,
313         "form": form,
314         "editable": editable,
315     })
316
317
318 @permission_required('catalogue.add_chunk')
319 def chunk_add(request, slug, chunk):
320     try:
321         doc = Chunk.get(slug, chunk)
322     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
323         raise Http404
324     if not doc.book.accessible(request):
325         return HttpResponseForbidden("Not authorized.")
326
327     if request.method == "POST":
328         form = forms.ChunkAddForm(request.POST, instance=doc)
329         if form.is_valid():
330             if request.user.is_authenticated():
331                 creator = request.user
332             else:
333                 creator = None
334             doc.split(creator=creator,
335                 slug=form.cleaned_data['slug'],
336                 title=form.cleaned_data['title'],
337                 gallery_start=form.cleaned_data['gallery_start'],
338                 user=form.cleaned_data['user'],
339                 stage=form.cleaned_data['stage']
340             )
341
342             return http.HttpResponseRedirect(doc.book.get_absolute_url())
343     else:
344         form = forms.ChunkAddForm(initial={
345                 "slug": str(doc.number + 1),
346                 "title": "cz. %d" % (doc.number + 1, ),
347         })
348
349     return render(request, "catalogue/chunk_add.html", {
350         "chunk": doc,
351         "form": form,
352     })
353
354
355 def chunk_edit(request, slug, chunk):
356     try:
357         doc = Chunk.get(slug, chunk)
358     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
359         raise Http404
360     if not doc.book.accessible(request):
361         return HttpResponseForbidden("Not authorized.")
362
363     if request.method == "POST":
364         form = forms.ChunkForm(request.POST, instance=doc)
365         if form.is_valid():
366             form.save()
367             go_next = request.GET.get('next', None)
368             if go_next:
369                 go_next = urlquote_plus(unquote(iri_to_uri(go_next)), safe='/?=&')
370             else:
371                 go_next = doc.book.get_absolute_url()
372             return http.HttpResponseRedirect(go_next)
373     else:
374         form = forms.ChunkForm(instance=doc)
375
376     referer = request.META.get('HTTP_REFERER')
377     if referer:
378         parts = urlsplit(referer)
379         parts = ['', ''] + list(parts[2:])
380         go_next = urlquote_plus(urlunsplit(parts))
381     else:
382         go_next = ''
383
384     return render(request, "catalogue/chunk_edit.html", {
385         "chunk": doc,
386         "form": form,
387         "go_next": go_next,
388     })
389
390
391 @transaction.commit_on_success
392 def chunk_mass_edit(request):
393     if request.method == 'POST':
394         ids = map(int, filter(lambda i: i.strip()!='', request.POST.get('ids').split(',')))
395         chunks = map(lambda i: Chunk.objects.get(id=i), ids)
396         
397         stage = request.POST.get('stage')
398         if stage:
399             try:
400                 stage = Chunk.tag_model.objects.get(slug=stage)
401             except Chunk.DoesNotExist, e:
402                 stage = None
403            
404             for c in chunks: c.stage = stage
405
406         username = request.POST.get('user')
407         logger.info("username: %s" % username)
408         logger.info(request.POST)
409         if username:
410             try:
411                 user = User.objects.get(username=username)
412             except User.DoesNotExist, e:
413                 user = None
414                 
415             for c in chunks: c.user = user
416
417         status = request.POST.get('status')
418         if status:
419             books_affected = set()
420             for c in chunks:
421                 if status == 'publish':
422                     c.head.publishable = True
423                     c.head.save()
424                 elif status == 'unpublish':
425                     c.head.publishable = False
426                     c.head.save()
427                 c.touch()  # cache
428                 books_affected.add(c.book)
429             for b in books_affected:
430                 b.touch()  # cache
431
432         project_id = request.POST.get('project')
433         if project_id:
434             try:
435                 project = Project.objects.get(pk=int(project_id))
436             except (Project.DoesNotExist, ValueError), e:
437                 project = None
438             for c in chunks:
439                 book = c.book
440                 book.project = project
441                 book.save()
442
443         for c in chunks: c.save()
444
445         return HttpResponse("", content_type="text/plain")
446     else:
447         raise Http404
448
449
450 @permission_required('catalogue.change_book')
451 def book_append(request, slug):
452     book = get_object_or_404(Book, slug=slug)
453     if not book.accessible(request):
454         return HttpResponseForbidden("Not authorized.")
455
456     if request.method == "POST":
457         form = forms.BookAppendForm(book, request.POST)
458         if form.is_valid():
459             append_to = form.cleaned_data['append_to']
460             append_to.append(book)
461             return http.HttpResponseRedirect(append_to.get_absolute_url())
462     else:
463         form = forms.BookAppendForm(book)
464     return render(request, "catalogue/book_append_to.html", {
465         "book": book,
466         "form": form,
467
468         "logout_to": '/',
469     })
470
471
472 @require_POST
473 @login_required
474 def publish(request, slug):
475     book = get_object_or_404(Book, slug=slug)
476     if not book.accessible(request):
477         return HttpResponseForbidden("Not authorized.")
478
479     try:
480         book.publish(request.user)
481     except NotAuthorizedError:
482         return http.HttpResponseRedirect(reverse('apiclient_oauth'))
483     except BaseException, e:
484         return http.HttpResponse(e)
485     else:
486         return http.HttpResponseRedirect(book.get_absolute_url())
487
488
489 class GalleryView(UploadView):
490     def get_object(self, request, slug):
491         book = get_object_or_404(Book, slug=slug)
492         if not book.gallery:
493             raise Http404
494         return book
495
496     def breadcrumbs(self):
497         return [
498             (_('books'), reverse('catalogue_document_list')),
499             (self.object.title, self.object.get_absolute_url()),
500             (_('scan gallery'),),
501         ]
502
503     def get_directory(self):
504         return "%s%s/" % (settings.IMAGE_DIR, self.object.gallery)