tutorial and help texts for tags in new resource form
[redakcja.git] / apps / catalogue / views.py
1 # -*- coding: utf-8 -*-
2 #
3 # This file is part of MIL/PEER, licensed under GNU Affero GPLv3 or later.
4 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
5 #
6 import logging
7 import os
8 import shutil
9 import subprocess
10 from tempfile import NamedTemporaryFile
11
12 from django.conf import settings
13 from django.contrib import auth
14 from django.contrib.auth.models import User
15 from django.contrib.auth.decorators import login_required
16 from django.contrib.sites.models import Site
17 from django.core.urlresolvers import reverse
18 from django import http
19 from django.http import Http404, HttpResponse, HttpResponseForbidden
20 from django.shortcuts import get_object_or_404, render, redirect
21 from django.utils.encoding import force_str
22 from django.utils.http import urlquote_plus
23 from django.views.decorators.http import require_POST
24 from unidecode import unidecode
25
26 from catalogue import forms
27 from catalogue.forms import TagMultipleForm, TagSingleForm
28 from catalogue.helpers import active_tab
29 from catalogue.models import Category
30 from librarian import BuildError
31 from redakcja.utlis import send_notify_email
32 from .constants import STAGES
33 from .models import Document, Plan
34 from dvcs.models import Revision
35 from organizations.models import Organization
36 from fileupload.views import UploadView
37
38 #
39 # Quick hack around caching problems, TODO: use ETags
40 #
41 from django.views.decorators.cache import never_cache
42 # from fnpdjango.utils.text.slughifi import slughifi
43
44 logger = logging.getLogger("fnp.catalogue")
45
46
47 @never_cache
48 def user(request, username):
49     user = get_object_or_404(User, username=username)
50     return render(request, 'catalogue/user_page.html', {"viewed_user": user})
51
52
53 @login_required
54 @active_tab('my')
55 @never_cache
56 def my(request):
57     return render(request, 'catalogue/my_page.html', {
58         'last_books': sorted(
59             request.session.get("wiki_last_books", {}).items(), key=lambda x: x[1]['time'], reverse=True),
60
61         "logout_to": '/',
62         })
63
64
65 @never_cache
66 def logout_then_redirect(request):
67     auth.logout(request)
68     return http.HttpResponseRedirect(urlquote_plus(request.GET.get('next', '/'), safe='/?='))
69
70
71 @login_required
72 @active_tab('create')
73 def create_missing(request):
74     if request.method == "POST":
75         form = forms.DocumentCreateForm(request.POST, request.FILES)
76         tag_forms = [
77             (TagMultipleForm if category.multiple else TagSingleForm)(
78                 category=category, data=request.POST, prefix=category.dc_tag)
79             for category in Category.objects.all()]
80         if form.is_valid() and all(tag_form.is_valid() for tag_form in tag_forms):
81             
82             if request.user.is_authenticated():
83                 creator = request.user
84             else:
85                 creator = None
86
87             title = form.cleaned_data['title']
88             try:
89                 org = request.user.membership_set.get(
90                     organization=int(form.cleaned_data['owner_organization'])).organization
91                 kwargs = {'owner_organization': org}
92             except:
93                 kwargs = {'owner_user': request.user}
94
95             doc = Document.objects.create(**kwargs)
96
97             cover = request.FILES.get('cover')
98             if cover:
99                 uppath = 'uploads/%d/' % doc.pk
100                 path = settings.MEDIA_ROOT + uppath
101                 if not os.path.isdir(path):
102                     os.makedirs(path)
103                 cover.name = unidecode(cover.name)
104                 dest_path = path + cover.name
105                 if not os.path.abspath(dest_path).startswith(os.path.abspath(path)):
106                     raise Http404
107                 with open(dest_path, 'w') as destination:
108                     for chunk in cover.chunks():
109                         destination.write(chunk)
110                 cover_url = 'http://milpeer.eu/media/dynamic/' + uppath + cover.name
111             else:
112                 cover_url = ''
113
114             doc.commit(
115                 text='''<section xmlns="http://nowoczesnapolska.org.pl/sst#" xmlns:dc="http://purl.org/dc/elements/1.1/">
116                 <metadata>
117                     <dc:publisher>''' + form.cleaned_data['publisher'] + '''</dc:publisher>
118                     <dc:description>''' + form.cleaned_data['description'] + '''</dc:description>
119                     <dc:language>''' + form.cleaned_data['language'] + '''</dc:language>
120                     <dc:rights>''' + form.cleaned_data['rights'] + '''</dc:rights>
121                     <dc:audience>''' + form.cleaned_data['audience'] + '''</dc:audience>
122                     <dc:relation.coverImage.url>''' + cover_url + '''</dc:relation.coverImage.url>
123                 </metadata>
124                 <header>''' + title + '''</header>
125                 <div class="p"> </div>
126                 </section>''',
127                 author=creator
128             )
129             doc.assigned_to = request.user
130             doc.save()
131
132             return http.HttpResponseRedirect(reverse("wiki_editor", args=[doc.pk]))
133     else:
134         org_pk = request.GET.get('organization')
135         if org_pk:
136             try:
137                 org = Organization.objects.get(pk=org_pk)
138             except Organization.DoesNotExist:
139                 org = None
140             else:
141                 if not org.is_member(request.user):
142                     org = None
143         else:
144             org = None
145         if org is not None:
146             org = org.pk
147
148         form = forms.DocumentCreateForm(initial={'owner_organization': org})
149
150         tag_forms = [
151             (TagMultipleForm if category.multiple else TagSingleForm)(
152                 category=category, tutorial_no=i, prefix=category.dc_tag)
153             for i, category in enumerate(Category.objects.all(), start=2)]
154
155     return render(request, "catalogue/document_create_missing.html", {
156         "form": form,
157         "tag_forms": tag_forms,
158
159         "logout_to": '/',
160     })
161
162
163 @never_cache
164 def book_html(request, pk, rev_pk=None, preview=False):
165     from librarian.document import Document as SST
166     from librarian.formats.html import HtmlFormat
167
168     doc = get_object_or_404(Document, pk=pk, deleted=False)
169
170     try:
171         published_revision = doc.publish_log.all()[0].revision
172     except IndexError:
173         published_revision = None
174
175     if rev_pk is None:
176         if preview:
177             revision = doc.revision
178         else:
179             if published_revision is not None:
180                 revision = published_revision
181             else:
182                 # No published version, fallback to preview mode.
183                 preview = True
184                 revision = doc.revision
185     else:
186         revision = get_object_or_404(Revision, pk=rev_pk)
187
188     was_published = revision == published_revision or doc.publish_log.filter(revision=revision).exists()
189
190     try:
191         sst = SST.from_string(revision.materialize())
192     except ValueError as e:
193         html = e
194     else:
195         html = HtmlFormat(sst).build(
196             files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk)).get_string()
197
198     # response = http.HttpResponse(html, content_type='text/html', mimetype='text/html')
199     # return response
200     # book_themes = {}
201     # for fragment in book.fragments.all().iterator():
202     #     for theme in fragment.tags.filter(category='theme').iterator():
203     #         book_themes.setdefault(theme, []).append(fragment)
204
205     # book_themes = book_themes.items()
206     # book_themes.sort(key=lambda s: s[0].sort_key)
207     return render(request, 'catalogue/book_text.html', {
208         'doc': doc,
209         'preview': preview,
210         'revision': revision,
211         'published_revision': published_revision,
212         'specific': rev_pk is not None,
213         'html': html,
214         'can_edit': doc.can_edit(request.user) if doc else None,
215         'was_published': was_published,
216     })
217
218
219 @never_cache
220 def book_pdf(request, pk, rev_pk):
221     from librarian.utils import Context
222     from librarian.document import Document as SST
223     from librarian.formats.pdf import PdfFormat
224
225     doc = get_object_or_404(Document, pk=pk)
226     rev = get_object_or_404(Revision, pk=rev_pk)
227     # Test
228
229     try:
230         sst = SST.from_string(rev.materialize())
231     except ValueError as e:
232         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
233     
234     ctx = Context(
235         files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk),
236         source_url='http://%s%s' % (request.get_host(), reverse('catalogue_html', args=[doc.pk])),
237     )
238     if doc.owner_organization is not None and doc.owner_organization.logo:
239         ctx.cover_logo = 'http://%s%s' % (request.get_host(), doc.owner_organization.logo.url)
240     try:
241         pdf_file = PdfFormat(sst).build(ctx)
242     except BuildError as e:
243         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
244
245     from catalogue.ebook_utils import serve_file
246     return serve_file(pdf_file.get_filename(), '%d.pdf' % doc.pk, 'application/pdf')
247
248
249 @never_cache
250 def book_epub(request, pk, rev_pk):
251     from librarian.utils import Context
252     from librarian.document import Document as SST
253     from librarian.formats.epub import EpubFormat
254
255     doc = get_object_or_404(Document, pk=pk)
256     rev = get_object_or_404(Revision, pk=rev_pk)
257     # Test
258
259     try:
260         sst = SST.from_string(rev.materialize())
261     except ValueError as e:
262         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
263
264     ctx = Context(
265         files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk),
266         source_url='http://%s%s' % (request.get_host(), reverse('catalogue_html', args=[doc.pk])),
267     )
268     if doc.owner_organization is not None and doc.owner_organization.logo:
269         ctx.cover_logo = 'http://%s%s' % (request.get_host(), doc.owner_organization.logo.url)
270     try:
271         epub_file = EpubFormat(sst).build(ctx)
272     except BuildError as e:
273         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
274
275     from catalogue.ebook_utils import serve_file
276     return serve_file(epub_file.get_filename(), '%d.epub' % doc.pk, 'application/epub+zip')
277
278
279 @never_cache
280 def book_mobi(request, pk, rev_pk):
281     from librarian.utils import Context
282     from librarian.document import Document as SST
283     from librarian.formats.epub import EpubFormat
284
285     doc = get_object_or_404(Document, pk=pk)
286     rev = get_object_or_404(Revision, pk=rev_pk)
287
288     try:
289         sst = SST.from_string(rev.materialize())
290     except ValueError as e:
291         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
292
293     ctx = Context(
294         files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk),
295         source_url='http://%s%s' % (request.get_host(), reverse('catalogue_html', args=[doc.pk])),
296     )
297     if doc.owner_organization is not None and doc.owner_organization.logo:
298         ctx.cover_logo = 'http://%s%s' % (request.get_host(), doc.owner_organization.logo.url)
299     try:
300         epub_file = EpubFormat(sst).build(ctx)
301     except BuildError as e:
302         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
303
304     output_file = NamedTemporaryFile(prefix='librarian', suffix='.mobi', delete=False)
305     output_file.close()
306     subprocess.check_call(
307         ['ebook-convert', epub_file.get_filename(), output_file.name, '--no-inline-toc'])
308
309     from catalogue.ebook_utils import serve_file
310     return serve_file(output_file.name, '%d.mobi' % doc.pk, 'application/epub+zip')
311
312
313 # @never_cache
314 # def revision(request, slug, chunk=None):
315 #     try:
316 #         doc = Chunk.get(slug, chunk)
317 #     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
318 #         raise Http404
319 #     if not doc.book.accessible(request):
320 #         return HttpResponseForbidden("Not authorized.")
321 #     return http.HttpResponse(str(doc.revision()))
322
323
324 @login_required
325 def book_schedule(request, pk):
326     book = get_object_or_404(Document, pk=pk, deleted=False)
327     if not book.can_edit(request.user):
328         return HttpResponseForbidden("Not authorized.")
329     if request.method == 'POST':
330         Plan.objects.filter(document=book).delete()
331         for i, (s, name) in enumerate(STAGES):
332             user_id = request.POST.get('s%d-user' % i)
333             deadline = request.POST.get('s%d-deadline' % i) or None
334             Plan.objects.create(document=book, stage=s, user_id=user_id, deadline=deadline)
335
336         book.set_stage(request.POST.get('stage', ''))
337         return redirect('catalogue_user')
338
339     current = {}
340     for p in Plan.objects.filter(document=book):
341         current[p.stage] = (getattr(p.user, 'pk', None), (p.deadline.isoformat() if p.deadline else None))
342
343     schedule = [(i, s, current.get(s, ())) for i, (s, name) in enumerate(STAGES)]
344     
345     if book.owner_organization:
346         people = [m.user for m in book.owner_organization.membership_set.exclude(status='pending')]
347     else:
348         people = [book.owner_user]
349     return render(request, 'catalogue/book_schedule.html', {
350         'book': book,
351         'schedule': schedule,
352         'people': people,
353     })
354
355
356 @login_required
357 def book_owner(request, pk):
358     doc = get_object_or_404(Document, pk=pk, deleted=False)
359     if not doc.can_edit(request.user):
360         return HttpResponseForbidden("Not authorized.")
361
362     error = ''
363
364     if request.method == 'POST':
365         # TODO: real form
366         new_org_pk = request.POST.get('owner_organization')
367         if not new_org_pk:
368             doc.owner_organization = None
369             doc.owner_user = request.user
370             doc.save()
371         else:
372             org = Organization.objects.get(pk=new_org_pk)
373             if not org.is_member(request.user):
374                 error = 'Bad organization'
375             else:
376                 doc.owner_organization = org
377                 doc.owner_user = None
378                 doc.save()
379         if not error:
380             return redirect('catalogue_user')
381
382     return render(request, 'catalogue/book_owner.html', {
383         'doc': doc,
384         'error': error,
385     })
386
387
388 @login_required
389 def book_delete(request, pk):
390     doc = get_object_or_404(Document, pk=pk, deleted=False)
391     if not doc.can_edit(request.user):
392         return HttpResponseForbidden("Not authorized.")
393
394     if request.method == 'POST':
395         doc.deleted = True
396         doc.save()
397         return redirect('catalogue_user')
398
399     return render(request, 'catalogue/book_delete.html', {
400         'doc': doc,
401     })
402
403
404 @require_POST
405 @login_required
406 def publish(request, pk):
407     from wiki import forms
408     from .models import PublishRecord
409     from dvcs.models import Revision
410
411     doc = get_object_or_404(Document, pk=pk, deleted=False)
412     if not doc.can_edit(request.user):
413         return HttpResponseForbidden("Not authorized.")
414     form = forms.DocumentTextPublishForm(request.POST, prefix="textpublish")
415     if form.is_valid():
416         rev = Revision.objects.get(pk=form.cleaned_data['revision'])
417         # FIXME: check if in tree
418         # if PublishRecord.objects.filter(revision=rev, document=doc).exists():
419         #     return http.HttpResponse('exists')
420         if not doc.published:
421             site = Site.objects.get_current()
422             send_notify_email(
423                 'New published document in MIL/PEER',
424                 '''New published document in MIL/PEER: %s. View it in browser: https://%s%s.
425
426 --
427 MIL/PEER team.''' % (doc.meta()['title'], site.domain, reverse('catalogue_html', args=[doc.pk])))
428         PublishRecord.objects.create(revision=rev, document=doc, user=request.user)
429         doc.published = True
430         doc.save()
431         if request.is_ajax():
432             return http.HttpResponse('ok')
433         else:
434             return redirect('catalogue_html', doc.pk)
435     else:
436         if request.is_ajax():
437             return http.HttpResponse('error')
438         else:
439             try:
440                 return redirect('catalogue_preview_rev', doc.pk, form.cleaned_data['revision'])
441             except KeyError:
442                 return redirect('catalogue_preview', doc.pk)
443
444
445 @require_POST
446 @login_required
447 def unpublish(request, pk):
448     doc = get_object_or_404(Document, pk=pk, deleted=False)
449     if not doc.can_edit(request.user):
450         return HttpResponseForbidden("Not authorized.")
451
452     doc.publish_log.all().delete()
453     if request.is_ajax():
454         return http.HttpResponse('ok')
455     else:
456         return redirect('catalogue_html', doc.pk)
457
458
459 class GalleryMixin(object):
460     def get_directory(self):
461         # return "%s%s/" % (settings.IMAGE_DIR, 'org%d' % self.org.pk if self.org is not None else self.request.user.pk)
462         return "uploads/%d/" % self.doc.pk
463
464
465 class GalleryView(GalleryMixin, UploadView):
466
467     def breadcrumbs(self):
468         return [
469                 (self.doc.meta()['title'], '/documents/%d/' % self.doc.pk),
470             ]
471
472     def get_object(self, request, pk=None):
473         self.doc = Document.objects.get(pk=pk, deleted=False)
474
475
476 @login_required
477 def fork(request, pk):
478     doc = get_object_or_404(Document, pk=pk, deleted=False)
479     if request.method == "POST":
480         form = forms.DocumentForkForm(request.POST, request.FILES)
481         if form.is_valid():
482             try:
483                 org = request.user.membership_set.get(
484                     organization=int(form.cleaned_data['owner_organization'])).organization
485                 kwargs = {'owner_organization': org}
486             except:
487                 kwargs = {'owner_user': request.user}
488
489             new_doc = Document.objects.create(revision=doc.revision, **kwargs)
490
491             if os.path.isdir(settings.MEDIA_ROOT + "uploads/%d" % doc.pk):
492                 shutil.copytree(
493                     settings.MEDIA_ROOT + "uploads/%d" % doc.pk,
494                     settings.MEDIA_ROOT + "uploads/%d" % new_doc.pk
495                 )
496
497             new_doc.assigned_to = request.user
498             new_doc.save()
499
500             return http.HttpResponseRedirect(reverse("wiki_editor", args=[new_doc.pk]))
501     else:
502         form = forms.DocumentForkForm()
503
504     return render(request, "catalogue/document_fork.html", {
505         "form": form,
506
507         "logout_to": '/',
508     })
509
510
511 def upcoming(request):
512     return render(request, "catalogue/upcoming.html", {
513         'objects_list': Document.objects.filter(deleted=False).filter(publish_log=None),
514     })
515
516
517 def finished(request):
518     return render(request, "catalogue/finished.html", {
519         'objects_list': Document.objects.filter(deleted=False).exclude(publish_log=None),
520     })