Fixes
[redakcja.git] / src / documents / views.py
1 # This file is part of FNP-Redakcja, licensed under GNU Affero GPLv3 or later.
2 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
3 #
4 from collections import defaultdict
5 from copy import deepcopy
6 from datetime import datetime, date, timedelta
7 from itertools import zip_longest
8 import json
9 import logging
10 import os
11 from urllib.parse import quote_plus, unquote, urlsplit, urlunsplit
12
13 from django.conf import settings
14 from django.contrib import auth, messages
15 from django.contrib.auth.models import User
16 from django.contrib.auth.decorators import login_required, permission_required
17 from django.urls import reverse
18 from django.db.models import Count, Q
19 from django.db import transaction
20 from django import http
21 from django.http import Http404, HttpResponse, HttpResponseForbidden
22 from django.http.response import HttpResponseRedirect
23 from django.shortcuts import get_object_or_404, render
24 from django.utils.encoding import iri_to_uri
25 from django.utils.translation import gettext_lazy as _
26 from django.views.decorators.http import require_POST
27 from django_cas_ng.decorators import user_passes_test
28 import requests
29 from lxml import etree
30
31 from librarian import epubcheck
32 from librarian.html import raw_printable_text
33
34 from apiclient import api_call, NotAuthorizedError
35 from . import forms
36 from . import helpers
37 from .helpers import active_tab
38 from .models import (Book, Chunk, Image, BookPublishRecord, 
39         ChunkPublishRecord, ImagePublishRecord, Project)
40 import catalogue.models
41 from fileupload.views import UploadView
42
43 #
44 # Quick hack around caching problems, TODO: use ETags
45 #
46 from django.views.decorators.cache import never_cache
47
48 logger = logging.getLogger("fnp.documents")
49
50
51 @active_tab('all')
52 @never_cache
53 def document_list(request):
54     return render(request, 'documents/document_list.html')
55
56
57 @active_tab('images')
58 @never_cache
59 def image_list(request, user=None):
60     return render(request, 'documents/image_list.html')
61
62
63 @never_cache
64 def user(request, username):
65     user = get_object_or_404(User, username=username)
66     return render(request, 'documents/user_page.html', {"viewed_user": user})
67
68
69 @login_required
70 @active_tab('my')
71 @never_cache
72 def my(request):
73     last_books = sorted(request.session.get("wiki_last_books", {}).items(),
74         key=lambda x: x[1]['time'], reverse=True)
75     for k, v in last_books:
76         v['time'] = datetime.fromtimestamp(v['time'])
77     try:
78         resp = api_call(request.user, 'username/')
79     except NotAuthorizedError:
80         wllogin = None
81     else:
82         wllogin = resp['username']
83
84     return render(request, 'documents/my_page.html', {
85         'last_books': last_books,
86         "logout_to": '/',
87         "wllogin": wllogin,
88         })
89
90
91 @active_tab('users')
92 def users(request):
93     return render(request, 'documents/user_list.html', {
94         'users': User.objects.all().annotate(count=Count('chunk')).order_by(
95             '-count', 'last_name', 'first_name'),
96     })
97
98
99 @active_tab('activity')
100 def activity(request, isodate=None):
101     today = date.today()
102     try:
103         day = helpers.parse_isodate(isodate)
104     except ValueError:
105         day = today
106
107     if day > today:
108         raise Http404
109     if day != today:
110         next_day = day + timedelta(1)
111     prev_day = day - timedelta(1)
112
113     return render(request, 'documents/activity.html', locals())
114
115
116 @never_cache
117 def logout_then_redirect(request):
118     auth.logout(request)
119     return http.HttpResponseRedirect(quote_plus(request.GET.get('next', '/'), safe='/?='))
120
121
122 @permission_required('documents.add_book')
123 @active_tab('create')
124 def create_missing(request, slug=None):
125     if slug is None:
126         slug = ''
127     slug = slug.replace(' ', '-')
128
129     if request.method == "POST":
130         form = forms.DocumentCreateForm(request.POST, request.FILES)
131         if form.is_valid():
132             
133             if request.user.is_authenticated:
134                 creator = request.user
135             else:
136                 creator = None
137             book = Book.create(
138                 text=form.cleaned_data['text'],
139                 creator=creator,
140                 slug=form.cleaned_data['slug'],
141                 title=form.cleaned_data['title'],
142                 gallery=form.cleaned_data['gallery'],
143             )
144
145             return http.HttpResponseRedirect(reverse("documents_book", args=[book.slug]))
146     else:
147         form = forms.DocumentCreateForm(initial={
148                 "slug": slug,
149                 "title": slug.replace('-', ' ').title(),
150                 "gallery": slug,
151         })
152
153     return render(request, "documents/document_create_missing.html", {
154         "slug": slug,
155         "form": form,
156
157         "logout_to": '/',
158     })
159
160
161 @permission_required('documents.add_book')
162 @active_tab('upload')
163 def upload(request):
164     if request.method == "POST":
165         form = forms.DocumentsUploadForm(request.POST, request.FILES)
166         if form.is_valid():
167             from slugify import slugify
168
169             if request.user.is_authenticated:
170                 creator = request.user
171             else:
172                 creator = None
173
174             zip = form.cleaned_data['zip']
175             skipped_list = []
176             ok_list = []
177             error_list = []
178             slugs = {}
179             existing = [book.slug for book in Book.objects.all()]
180             for filename in zip.namelist():
181                 if filename[-1] == '/':
182                     continue
183                 title = os.path.basename(filename)[:-4]
184                 slug = slugify(title)
185                 if not (slug and filename.endswith('.xml')):
186                     skipped_list.append(filename)
187                 elif slug in slugs:
188                     error_list.append((filename, slug, _('Slug already used for %s' % slugs[slug])))
189                 elif slug in existing:
190                     error_list.append((filename, slug, _('Slug already used in repository.')))
191                 else:
192                     try:
193                         zip.read(filename).decode('utf-8') # test read
194                         ok_list.append((filename, slug, title))
195                     except UnicodeDecodeError:
196                         error_list.append((filename, title, _('File should be UTF-8 encoded.')))
197                     slugs[slug] = filename
198
199             if not error_list:
200                 for filename, slug, title in ok_list:
201                     book = Book.create(
202                         text=zip.read(filename).decode('utf-8'),
203                         creator=creator,
204                         slug=slug,
205                         title=title,
206                     )
207
208             return render(request, "documents/document_upload.html", {
209                 "form": form,
210                 "ok_list": ok_list,
211                 "skipped_list": skipped_list,
212                 "error_list": error_list,
213
214                 "logout_to": '/',
215             })
216     else:
217         form = forms.DocumentsUploadForm()
218
219     return render(request, "documents/document_upload.html", {
220         "form": form,
221
222         "logout_to": '/',
223     })
224
225
226 def serve_xml(request, book, slug):
227     if not book.accessible(request):
228         return HttpResponseForbidden("Not authorized.")
229     xml = book.materialize(publishable=True)
230     response = http.HttpResponse(xml, content_type='application/xml')
231     response['Content-Disposition'] = 'attachment; filename=%s.xml' % slug
232     return response
233
234
235 @never_cache
236 def book_xml(request, slug):
237     book = get_object_or_404(Book, slug=slug)
238     return serve_xml(request, book, slug)
239
240
241 @never_cache
242 def book_xml_dc(request, slug):
243     book = get_object_or_404(Book, dc_slug=slug)
244     return serve_xml(request, book, slug)
245
246
247 @never_cache
248 def book_txt(request, slug):
249     book = get_object_or_404(Book, slug=slug)
250     if not book.accessible(request):
251         return HttpResponseForbidden("Not authorized.")
252
253     doc = book.wldocument()
254     text = doc.as_text().get_bytes()
255     response = http.HttpResponse(text, content_type='text/plain')
256     response['Content-Disposition'] = 'attachment; filename=%s.txt' % slug
257     return response
258
259
260 @never_cache
261 def book_html(request, slug):
262     book = get_object_or_404(Book, slug=slug)
263     if not book.accessible(request):
264         return HttpResponseForbidden("Not authorized.")
265
266     doc = book.wldocument(parse_dublincore=False)
267     html = doc.as_html(
268         gallery_url='%stmp/html/' % settings.MEDIA_URL,
269         gallery_path='%s/tmp/html/' % settings.MEDIA_ROOT,
270         base_url=request.build_absolute_uri(book.gallery_url()),
271         options={'gallery': "'%s'" % book.gallery_url()})
272
273     html = html.get_bytes().decode('utf-8') if html is not None else ''
274     # response = http.HttpResponse(html, content_type='text/html')
275     # return response
276     # book_themes = {}
277     # for fragment in book.fragments.all().iterator():
278     #     for theme in fragment.tags.filter(category='theme').iterator():
279     #         book_themes.setdefault(theme, []).append(fragment)
280
281     # book_themes = book_themes.items()
282     # book_themes.sort(key=lambda s: s[0].sort_key)
283     return render(request, 'documents/book_text.html', locals())
284
285
286 @login_required
287 @never_cache
288 def book_pdf(request, slug, mobile=False):
289     book = get_object_or_404(Book, slug=slug)
290     if not book.accessible(request):
291         return HttpResponseForbidden("Not authorized.")
292
293     # TODO: move to celery
294     doc = book.wldocument()
295     # TODO: error handling
296     customizations = ['26pt', 'nothemes', 'nomargins', 'notoc'] if mobile else None
297     pdf_file = doc.as_pdf(cover=True, base_url=request.build_absolute_uri(book.gallery_url()), customizations=customizations)
298     from .ebook_utils import serve_file
299     return serve_file(pdf_file.get_filename(),
300                 book.slug + '.pdf', 'application/pdf')
301
302
303 @login_required
304 @never_cache
305 def book_epub(request, slug):
306     book = get_object_or_404(Book, slug=slug)
307     if not book.accessible(request):
308         return HttpResponseForbidden("Not authorized.")
309
310     # TODO: move to celery
311     doc = book.wldocument(librarian2=True)
312     # TODO: error handling
313
314     from librarian.builders import EpubBuilder
315     epub = EpubBuilder(
316         base_url='file://' + book.gallery_path() + '/',
317         debug=True
318     ).build(doc).get_bytes()
319     response = HttpResponse(content_type='application/epub+zip')
320     response['Content-Disposition'] = 'attachment; filename=%s' % book.slug + '.epub'
321     response.write(epub)
322     return response
323
324
325 @login_required
326 @never_cache
327 def book_epubcheck(request, slug):
328     book = get_object_or_404(Book, slug=slug)
329     if not book.accessible(request):
330         return HttpResponseForbidden("Not authorized.")
331
332     # TODO: move to celery
333     doc = book.wldocument(librarian2=True)
334     # TODO: error handling
335
336     from librarian.builders import EpubBuilder
337     epub = EpubBuilder(
338         base_url='file://' + book.gallery_path() + '/',
339         debug=True
340     ).build(doc)
341     fname = epub.get_filename()
342
343     messages = epubcheck.epubcheck(fname)
344     for message in messages:
345         for location in message.get('locations', []):
346             if 'wl_chunk' in location:
347                 location['wl_chunk'] = book[location['wl_chunk']]
348     return render(request, 'documents/book_epubcheck.html', {
349         'messages': messages,
350         'book': book,
351     })
352
353
354 @login_required
355 @never_cache
356 def book_mobi(request, slug):
357     book = get_object_or_404(Book, slug=slug)
358     if not book.accessible(request):
359         return HttpResponseForbidden("Not authorized.")
360
361     # TODO: move to celery
362     doc = book.wldocument(librarian2=True)
363     # TODO: error handling
364     from librarian.builders import MobiBuilder
365     mobi = MobiBuilder(
366         base_url='file://' + book.gallery_path() + '/'
367     ).build(doc).get_bytes()
368     response = HttpResponse(content_type='application/x-mobipocket-ebook')
369     response['Content-Disposition'] = 'attachment; filename=%s' % book.slug + '.mobi'
370     response.write(mobi)
371     return response
372
373
374 @never_cache
375 def revision(request, slug, chunk=None):
376     try:
377         doc = Chunk.get(slug, chunk)
378     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
379         raise Http404
380     if not doc.book.accessible(request):
381         return HttpResponseForbidden("Not authorized.")
382     return http.HttpResponse(str(doc.revision()))
383
384
385 def book(request, slug):
386     book = get_object_or_404(Book, slug=slug)
387     if not book.accessible(request):
388         return HttpResponseForbidden("Not authorized.")
389
390     if request.user.has_perm('documents.change_book'):
391         if request.method == "POST":
392             form = forms.BookForm(request.POST, instance=book)
393             if form.is_valid():
394                 form.save()
395                 return http.HttpResponseRedirect(book.get_absolute_url())
396         else:
397             form = forms.BookForm(instance=book)
398         publish_options_form = forms.PublishOptionsForm()
399         editable = True
400     else:
401         form = forms.ReadonlyBookForm(instance=book)
402         publish_options_form = forms.PublishOptionsForm()
403         editable = False
404
405     publish_error = book.publishable_error()
406     publishable = publish_error is None
407
408     stats = None
409     try:
410         doc = book.wldocument(librarian2=True)
411     except:
412         doc = None
413     else:
414         try:
415             stats = doc.get_statistics()
416         except:
417             pass
418
419     cbook_by_slug = None
420     if book.dc_slug:
421         try:
422             audio_items = requests.get(f'https://audio.wolnelektury.pl/archive/book/{book.dc_slug}.json').json()['items']
423         except:
424             has_audio = None
425             can_sell_audio = None
426         else:
427             has_audio = bool(audio_items)
428             can_sell_audio = has_audio and all(x['project']['can_sell'] for x in audio_items)
429
430         if book.catalogue_book is None or book.dc_slug != book.catalogue_book.slug:
431             cbook_by_slug = catalogue.models.Book.objects.filter(slug=book.dc_slug).first()
432     else:
433         has_audio = None
434         can_sell_audio = None
435
436     return render(request, "documents/book_detail.html", {
437         "book": book,
438         "doc": doc,
439         "stats": stats,
440         "publishable": publishable,
441         "publishable_error": publish_error,
442         "form": form,
443         "publish_options_form": publish_options_form,
444         "editable": editable,
445         "has_audio": has_audio,
446         "can_sell_audio": can_sell_audio,
447         "cbook_by_slug": cbook_by_slug,
448     })
449
450
451 def image(request, slug):
452     image = get_object_or_404(Image, slug=slug)
453     if not image.accessible(request):
454         return HttpResponseForbidden("Not authorized.")
455
456     if request.user.has_perm('documents.change_image'):
457         if request.method == "POST":
458             form = forms.ImageForm(request.POST, instance=image)
459             if form.is_valid():
460                 form.save()
461                 return http.HttpResponseRedirect(image.get_absolute_url())
462         else:
463             form = forms.ImageForm(instance=image)
464         editable = True
465     else:
466         form = forms.ReadonlyImageForm(instance=image)
467         editable = False
468
469     publish_error = image.publishable_error()
470     publishable = publish_error is None
471
472     return render(request, "documents/image_detail.html", {
473         "object": image,
474         "publishable": publishable,
475         "publishable_error": publish_error,
476         "form": form,
477         "editable": editable,
478     })
479
480
481 @permission_required('documents.add_chunk')
482 def chunk_add(request, slug, chunk):
483     try:
484         doc = Chunk.get(slug, chunk)
485     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
486         raise Http404
487     if not doc.book.accessible(request):
488         return HttpResponseForbidden("Not authorized.")
489
490     if request.method == "POST":
491         form = forms.ChunkAddForm(request.POST, instance=doc)
492         if form.is_valid():
493             if request.user.is_authenticated:
494                 creator = request.user
495             else:
496                 creator = None
497             doc.split(creator=creator,
498                 slug=form.cleaned_data['slug'],
499                 title=form.cleaned_data['title'],
500                 gallery_start=form.cleaned_data['gallery_start'],
501                 user=form.cleaned_data['user'],
502                 stage=form.cleaned_data['stage']
503             )
504
505             return http.HttpResponseRedirect(doc.book.get_absolute_url())
506     else:
507         form = forms.ChunkAddForm(initial={
508                 "slug": str(doc.number + 1),
509                 "title": "cz. %d" % (doc.number + 1, ),
510         })
511
512     return render(request, "documents/chunk_add.html", {
513         "chunk": doc,
514         "form": form,
515     })
516
517
518 @login_required
519 def chunk_edit(request, slug, chunk):
520     try:
521         doc = Chunk.get(slug, chunk)
522     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
523         raise Http404
524     if not doc.book.accessible(request):
525         return HttpResponseForbidden("Not authorized.")
526
527     if request.method == "POST":
528         form = forms.ChunkForm(request.POST, instance=doc)
529         if form.is_valid():
530             form.save()
531             go_next = request.GET.get('next', None)
532             if go_next:
533                 go_next = quote_plus(unquote(iri_to_uri(go_next)), safe='/?=&')
534             else:
535                 go_next = doc.book.get_absolute_url()
536             return http.HttpResponseRedirect(go_next)
537     else:
538         form = forms.ChunkForm(instance=doc)
539
540     referer = request.META.get('HTTP_REFERER')
541     if referer:
542         parts = urlsplit(referer)
543         parts = ['', ''] + list(parts[2:])
544         go_next = quote_plus(urlunsplit(parts))
545     else:
546         go_next = ''
547
548     return render(request, "documents/chunk_edit.html", {
549         "chunk": doc,
550         "form": form,
551         "go_next": go_next,
552     })
553
554
555 @transaction.atomic
556 @login_required
557 @require_POST
558 def chunk_mass_edit(request):
559     ids = [int(i) for i in request.POST.get('ids').split(',') if i.strip()]
560     chunks = list(Chunk.objects.filter(id__in=ids))
561     
562     stage = request.POST.get('stage')
563     if stage:
564         try:
565             stage = Chunk.tag_model.objects.get(slug=stage)
566         except Chunk.DoesNotExist as e:
567             stage = None
568        
569         for c in chunks: c.stage = stage
570
571     username = request.POST.get('user')
572     logger.info("username: %s" % username)
573     logger.info(request.POST)
574     if username:
575         try:
576             user = User.objects.get(username=username)
577         except User.DoesNotExist as e:
578             user = None
579             
580         for c in chunks: c.user = user
581
582     project_id = request.POST.get('project')
583     if project_id:
584         try:
585             project = Project.objects.get(pk=int(project_id))
586         except (Project.DoesNotExist, ValueError) as e:
587             project = None
588         for c in chunks:
589             book = c.book
590             book.project = project
591             book.save()
592
593     for c in chunks: c.save()
594
595     return HttpResponse("", content_type="text/plain")
596
597
598 @transaction.atomic
599 @login_required
600 @require_POST
601 def image_mass_edit(request):
602     ids = map(int, filter(lambda i: i.strip()!='', request.POST.get('ids').split(',')))
603     images = map(lambda i: Image.objects.get(id=i), ids)
604     
605     stage = request.POST.get('stage')
606     if stage:
607         try:
608             stage = Image.tag_model.objects.get(slug=stage)
609         except Image.DoesNotExist as e:
610             stage = None
611        
612         for c in images: c.stage = stage
613
614     username = request.POST.get('user')
615     logger.info("username: %s" % username)
616     logger.info(request.POST)
617     if username:
618         try:
619             user = User.objects.get(username=username)
620         except User.DoesNotExist as e:
621             user = None
622             
623         for c in images: c.user = user
624
625     project_id = request.POST.get('project')
626     if project_id:
627         try:
628             project = Project.objects.get(pk=int(project_id))
629         except (Project.DoesNotExist, ValueError) as e:
630             project = None
631         for c in images:
632             c.project = project
633
634     for c in images: c.save()
635
636     return HttpResponse("", content_type="text/plain")
637
638
639 @permission_required('documents.change_book')
640 def book_append(request, slug):
641     book = get_object_or_404(Book, slug=slug)
642     if not book.accessible(request):
643         return HttpResponseForbidden("Not authorized.")
644
645     if request.method == "POST":
646         form = forms.BookAppendForm(book, request.POST)
647         if form.is_valid():
648             append_to = form.cleaned_data['append_to']
649             append_to.append(book)
650             return http.HttpResponseRedirect(append_to.get_absolute_url())
651     else:
652         form = forms.BookAppendForm(book)
653     return render(request, "documents/book_append_to.html", {
654         "book": book,
655         "form": form,
656
657         "logout_to": '/',
658     })
659
660
661 @require_POST
662 @login_required
663 def publish(request, slug):
664     form = forms.PublishOptionsForm(request.POST)
665     if form.is_valid():
666         days = form.cleaned_data['days']
667         beta = form.cleaned_data['beta']
668         hidden = form.cleaned_data['hidden']
669     else:
670         days = 0
671         beta = False
672         hidden = False
673     book = get_object_or_404(Book, slug=slug)
674     if not book.accessible(request):
675         return HttpResponseForbidden("Not authorized.")
676
677     try:
678         protocol = 'https://' if request.is_secure() else 'http://'
679         book.publish(request.user, host=protocol + request.get_host(), days=days, beta=beta, hidden=hidden)
680     except NotAuthorizedError:
681         return http.HttpResponseRedirect(reverse('apiclient_oauth' if not beta else 'apiclient_beta_oauth'))
682     except BaseException as e:
683         return http.HttpResponse(repr(e))
684     else:
685         return http.HttpResponseRedirect(book.get_absolute_url())
686
687
688 @require_POST
689 @login_required
690 def fix_ilustr(request, slug):
691     from .ilustr import IlustrFixer
692     book = get_object_or_404(Book, slug=slug)
693     protocol = 'https://' if request.is_secure() else 'http://'
694     fixer = IlustrFixer(protocol + request.get_host(), author=request.user)
695     with transaction.atomic():
696         fixer.fix_book(book)
697     if fixer.stats['unresolved'] or fixer.stats['conflicts']:
698         messages.warning(request, 'Nie wszystkie ilustracje udało się naprawić.')
699     elif fixer.stats['fixed']:
700         messages.success(request, 'Naprawiono adresy ilustracji.')
701     return http.HttpResponseRedirect(book.get_absolute_url())
702
703
704 @require_POST
705 @login_required
706 def publish_image(request, slug):
707     image = get_object_or_404(Image, slug=slug)
708     if not image.accessible(request):
709         return HttpResponseForbidden("Not authorized.")
710
711     try:
712         image.publish(request.user)
713     except NotAuthorizedError:
714         return http.HttpResponseRedirect(reverse('apiclient_oauth'))
715     except BaseException as e:
716         return http.HttpResponse(e)
717     else:
718         return http.HttpResponseRedirect(image.get_absolute_url())
719
720
721 class GalleryView(UploadView):
722     def get_object(self, request, slug):
723         book = get_object_or_404(Book, slug=slug)
724         if not book.gallery:
725             raise Http404
726         return book
727
728     def breadcrumbs(self):
729         return [
730             (_('books'), reverse('documents_document_list')),
731             (self.object.title, self.object.get_absolute_url()),
732             (_('scan gallery'),),
733         ]
734
735     def get_directory(self):
736         return "%s%s/" % (settings.IMAGE_DIR, self.object.gallery)
737
738
739 def active_users_list(request, csv=False):
740     year = int(request.GET.get('y', date.today().year))
741     by_user = defaultdict(lambda: 0)
742     by_email = defaultdict(lambda: 0)
743     names_by_email = defaultdict(set)
744     for change_model in (Chunk.change_model, Image.change_model):
745         for c in change_model.objects.filter(
746                 created_at__year=year).order_by(
747                 'author', 'author_email', 'author_name').values(
748                 'author', 'author_name', 'author_email').annotate(
749                 c=Count('author'), ce=Count('author_email')).distinct():
750             if c['author']:
751                 by_user[c['author']] += c['c']
752             else:
753                 by_email[c['author_email']] += c['ce']
754                 if (c['author_name'] or '').strip():
755                     names_by_email[c['author_email']].add(c['author_name'])
756     for user in User.objects.filter(pk__in=by_user):
757         by_email[user.email] += by_user[user.pk]
758         names_by_email[user.email].add("%s %s" % (user.first_name, user.last_name))
759
760     active_users = []
761     for email, count in by_email.items():
762         active_users.append((email, names_by_email[email], count))
763     active_users.sort(key=lambda x: -x[2])
764     if csv:
765         return http.HttpResponse(
766             '\n'.join((
767                 ','.join(
768                     (str(x[2]), x[0], ','.join(x[1]))
769                 )
770                 for x in active_users
771             )),
772             content_type='text/csv',
773             headers={
774                 'Content-Disposition': f'attachment; filename=redakcja-{year}.csv',
775             }
776         )
777     else:
778         return render(request, 'documents/active_users_list.html', {
779             'users': active_users,
780             'year': year,
781         })
782
783
784 @user_passes_test(lambda u: u.is_superuser)
785 def mark_final(request):
786     if request.method == 'POST':
787         form = forms.MarkFinalForm(data=request.POST)
788         if form.is_valid():
789             form.save()
790             return HttpResponseRedirect(reverse('mark_final_completed'))
791     else:
792         form = forms.MarkFinalForm()
793     return render(request, 'documents/mark_final.html', {'form': form})
794
795
796 def mark_final_completed(request):
797     return render(request, 'documents/mark_final_completed.html')
798
799
800 @login_required
801 def synchro(request, slug):
802     book = get_object_or_404(Book, slug=slug)
803     if not book.accessible(request):
804         return HttpResponseForbidden("Not authorized.")
805
806     if request.method == 'POST':
807         #hints = json.loads(request.POST.get('hints'))
808         chunk = book[0]
809         tree = etree.fromstring(chunk.head.materialize())
810         m = tree.find('.//meta[@id="synchro"]')
811         if m is None:
812             rdf = tree.find('.//{http://www.w3.org/1999/02/22-rdf-syntax-ns#}Description')
813             m = etree.SubElement(rdf, 'meta', id="synchro")
814             m.tail = '\n'
815         m.text = request.POST.get('hints')
816         text = etree.tostring(tree, encoding='unicode')
817         chunk.commit(text, author=request.user, description='Synchronizacja')
818         return HttpResponseRedirect('')
819     
820     document = book.wldocument(librarian2=True, publishable=False)
821
822     slug = document.meta.url.slug
823     error = None
824     try:
825         items = requests.get(f'https://audio.wolnelektury.pl/archive/book/{slug}.json').json()['items']
826     except:
827         error = 'Błąd połączenia z repozytorium audio.'
828         items = []
829     else:
830         mp3 = [
831             item['part'] for item in items
832         ]
833
834     split_on = (
835         'naglowek_rozdzial',
836         'naglowek_scena',
837     )
838     split_other = (
839         'naglowek_czesc',
840         'naglowek_akt',
841         'naglowek_podrozdzial',
842         'srodtytul',
843     )
844
845     headers = []
846     headers_other = []
847     master = document.tree.getroot()[-1]
848     for item in master:
849         if item.tag in split_on:
850             headers.append([
851                 item.tag,
852                 raw_printable_text(item),
853                 0,
854                 item.sourceline,
855             ])
856         if item.tag in split_other:
857             headers_other.append([
858                 item.tag,
859                 raw_printable_text(item),
860                 0,
861                 item.sourceline,
862             ])
863
864     hints = []
865     m = document.tree.find('.//meta[@id="synchro"]')
866     if m is not None:
867         try:
868             hints = json.loads(m.text)
869         except:
870             raise
871             pass
872     
873     return render(request, 'documents/synchro.html', {
874         'book': book,
875         'headers': headers,
876         'headers_other': headers_other,
877         'mp3': mp3,
878         'error': error,
879         'hints': hints,
880     })
881
882
883 @permission_required('documents.change_book')
884 def attach_book_to_catalogue(request, pk):
885     dbook = get_object_or_404(Book, pk=pk)
886     if dbook.dc_slug:
887         cbook = get_object_or_404(catalogue.models.Book, slug=dbook.dc_slug)
888         dbook.catalogue_book = cbook
889         dbook.save()
890     return http.HttpResponseRedirect(dbook.get_absolute_url())