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             for tag_form in tag_forms:
  98                 tag_form.save(instance=doc)
  99
 100             cover = request.FILES.get('cover')
 101             if cover:
 102                 uppath = 'uploads/%d/' % doc.pk
 103                 path = settings.MEDIA_ROOT + uppath
 104                 if not os.path.isdir(path):
 105                     os.makedirs(path)
 106                 cover.name = unidecode(cover.name)
 107                 dest_path = path + cover.name
 108                 if not os.path.abspath(dest_path).startswith(os.path.abspath(path)):
 109                     raise Http404
 110                 with open(dest_path, 'w') as destination:
 111                     for chunk in cover.chunks():
 112                         destination.write(chunk)
 113                 cover_url = 'http://milpeer.eu/media/dynamic/' + uppath + cover.name
 114             else:
 115                 cover_url = ''
 116
 117             doc.commit(
 118                 text='''<section xmlns="http://nowoczesnapolska.org.pl/sst#" xmlns:dc="http://purl.org/dc/elements/1.1/">
 119                 <metadata>
 120                     <dc:publisher>''' + form.cleaned_data['publisher'] + '''</dc:publisher>
 121                     <dc:description>''' + form.cleaned_data['description'] + '''</dc:description>
 122                     ''' + '\n'.join(tag_form.metadata_rows() for tag_form in tag_forms) + '''
 123                     <dc:relation.coverImage.url>''' + cover_url + '''</dc:relation.coverImage.url>
 124                 </metadata>
 125                 <header>''' + title + '''</header>
 126                 <div class="p"> </div>
 127                 </section>''',
 128                 author=creator
 129             )
 130             doc.assigned_to = request.user
 131             doc.save()
 132
 133             return http.HttpResponseRedirect(reverse("wiki_editor", args=[doc.pk]))
 134     else:
 135         org_pk = request.GET.get('organization')
 136         if org_pk:
 137             try:
 138                 org = Organization.objects.get(pk=org_pk)
 139             except Organization.DoesNotExist:
 140                 org = None
 141             else:
 142                 if not org.is_member(request.user):
 143                     org = None
 144         else:
 145             org = None
 146         if org is not None:
 147             org = org.pk
 148
 149         form = forms.DocumentCreateForm(initial={'owner_organization': org})
 150
 151         tag_forms = [
 152             (TagMultipleForm if category.multiple else TagSingleForm)(
 153                 category=category, tutorial_no=i, prefix=category.dc_tag)
 154             for i, category in enumerate(Category.objects.all(), start=2)]
 155
 156     return render(request, "catalogue/document_create_missing.html", {
 157         "form": form,
 158         "tag_forms": tag_forms,
 159
 160         "logout_to": '/',
 161     })
 162
 163
 164 @never_cache
 165 def book_html(request, pk, rev_pk=None, preview=False):
 166     from librarian.document import Document as SST
 167     from librarian.formats.html import HtmlFormat
 168
 169     doc = get_object_or_404(Document, pk=pk, deleted=False)
 170
 171     try:
 172         published_revision = doc.publish_log.all()[0].revision
 173     except IndexError:
 174         published_revision = None
 175
 176     if rev_pk is None:
 177         if preview:
 178             revision = doc.revision
 179         else:
 180             if published_revision is not None:
 181                 revision = published_revision
 182             else:
 183                 # No published version, fallback to preview mode.
 184                 preview = True
 185                 revision = doc.revision
 186     else:
 187         revision = get_object_or_404(Revision, pk=rev_pk)
 188
 189     was_published = revision == published_revision or doc.publish_log.filter(revision=revision).exists()
 190
 191     try:
 192         sst = SST.from_string(revision.materialize())
 193     except ValueError as e:
 194         html = e
 195     else:
 196         html = HtmlFormat(sst).build(
 197             files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk)).get_string()
 198
 199     # response = http.HttpResponse(html, content_type='text/html', mimetype='text/html')
 200     # return response
 201     # book_themes = {}
 202     # for fragment in book.fragments.all().iterator():
 203     #     for theme in fragment.tags.filter(category='theme').iterator():
 204     #         book_themes.setdefault(theme, []).append(fragment)
 205
 206     # book_themes = book_themes.items()
 207     # book_themes.sort(key=lambda s: s[0].sort_key)
 208     return render(request, 'catalogue/book_text.html', {
 209         'doc': doc,
 210         'preview': preview,
 211         'revision': revision,
 212         'published_revision': published_revision,
 213         'specific': rev_pk is not None,
 214         'html': html,
 215         'can_edit': doc.can_edit(request.user) if doc else None,
 216         'was_published': was_published,
 217     })
 218
 219
 220 @never_cache
 221 def book_pdf(request, pk, rev_pk):
 222     from librarian.utils import Context
 223     from librarian.document import Document as SST
 224     from librarian.formats.pdf import PdfFormat
 225
 226     doc = get_object_or_404(Document, pk=pk)
 227     rev = get_object_or_404(Revision, pk=rev_pk)
 228     # Test
 229
 230     try:
 231         sst = SST.from_string(rev.materialize())
 232     except ValueError as e:
 233         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
 234
 235     ctx = Context(
 236         files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk),
 237         source_url='http://%s%s' % (request.get_host(), reverse('catalogue_html', args=[doc.pk])),
 238     )
 239     if doc.owner_organization is not None and doc.owner_organization.logo:
 240         ctx.cover_logo = 'http://%s%s' % (request.get_host(), doc.owner_organization.logo.url)
 241     try:
 242         pdf_file = PdfFormat(sst).build(ctx)
 243     except BuildError as e:
 244         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
 245
 246     from catalogue.ebook_utils import serve_file
 247     return serve_file(pdf_file.get_filename(), '%d.pdf' % doc.pk, 'application/pdf')
 248
 249
 250 @never_cache
 251 def book_epub(request, pk, rev_pk):
 252     from librarian.utils import Context
 253     from librarian.document import Document as SST
 254     from librarian.formats.epub import EpubFormat
 255
 256     doc = get_object_or_404(Document, pk=pk)
 257     rev = get_object_or_404(Revision, pk=rev_pk)
 258     # Test
 259
 260     try:
 261         sst = SST.from_string(rev.materialize())
 262     except ValueError as e:
 263         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
 264
 265     ctx = Context(
 266         files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk),
 267         source_url='http://%s%s' % (request.get_host(), reverse('catalogue_html', args=[doc.pk])),
 268     )
 269     if doc.owner_organization is not None and doc.owner_organization.logo:
 270         ctx.cover_logo = 'http://%s%s' % (request.get_host(), doc.owner_organization.logo.url)
 271     try:
 272         epub_file = EpubFormat(sst).build(ctx)
 273     except BuildError as e:
 274         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
 275
 276     from catalogue.ebook_utils import serve_file
 277     return serve_file(epub_file.get_filename(), '%d.epub' % doc.pk, 'application/epub+zip')
 278
 279
 280 @never_cache
 281 def book_mobi(request, pk, rev_pk):
 282     from librarian.utils import Context
 283     from librarian.document import Document as SST
 284     from librarian.formats.epub import EpubFormat
 285
 286     doc = get_object_or_404(Document, pk=pk)
 287     rev = get_object_or_404(Revision, pk=rev_pk)
 288
 289     try:
 290         sst = SST.from_string(rev.materialize())
 291     except ValueError as e:
 292         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
 293
 294     ctx = Context(
 295         files_path='http://%s/media/dynamic/uploads/%s/' % (request.get_host(), pk),
 296         source_url='http://%s%s' % (request.get_host(), reverse('catalogue_html', args=[doc.pk])),
 297     )
 298     if doc.owner_organization is not None and doc.owner_organization.logo:
 299         ctx.cover_logo = 'http://%s%s' % (request.get_host(), doc.owner_organization.logo.url)
 300     try:
 301         epub_file = EpubFormat(sst).build(ctx)
 302     except BuildError as e:
 303         return HttpResponse(content=force_str(e.message), content_type='text/plain', status='400')
 304
 305     output_file = NamedTemporaryFile(prefix='librarian', suffix='.mobi', delete=False)
 306     output_file.close()
 307     subprocess.check_call(
 308         ['ebook-convert', epub_file.get_filename(), output_file.name, '--no-inline-toc'])
 309
 310     from catalogue.ebook_utils import serve_file
 311     return serve_file(output_file.name, '%d.mobi' % doc.pk, 'application/epub+zip')
 312
 313
 314 # @never_cache
 315 # def revision(request, slug, chunk=None):
 316 #     try:
 317 #         doc = Chunk.get(slug, chunk)
 318 #     except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist):
 319 #         raise Http404
 320 #     if not doc.book.accessible(request):
 321 #         return HttpResponseForbidden("Not authorized.")
 322 #     return http.HttpResponse(str(doc.revision()))
 323
 324
 325 @login_required
 326 def book_schedule(request, pk):
 327     book = get_object_or_404(Document, pk=pk, deleted=False)
 328     if not book.can_edit(request.user):
 329         return HttpResponseForbidden("Not authorized.")
 330     if request.method == 'POST':
 331         Plan.objects.filter(document=book).delete()
 332         for i, (s, name) in enumerate(STAGES):
 333             user_id = request.POST.get('s%d-user' % i)
 334             deadline = request.POST.get('s%d-deadline' % i) or None
 335             Plan.objects.create(document=book, stage=s, user_id=user_id, deadline=deadline)
 336
 337         book.set_stage(request.POST.get('stage', ''))
 338         return redirect('catalogue_user')
 339
 340     current = {}
 341     for p in Plan.objects.filter(document=book):
 342         current[p.stage] = (getattr(p.user, 'pk', None), (p.deadline.isoformat() if p.deadline else None))
 343
 344     schedule = [(i, s, current.get(s, ())) for i, (s, name) in enumerate(STAGES)]
 345
 346     if book.owner_organization:
 347         people = [m.user for m in book.owner_organization.membership_set.exclude(status='pending')]
 348     else:
 349         people = [book.owner_user]
 350     return render(request, 'catalogue/book_schedule.html', {
 351         'book': book,
 352         'schedule': schedule,
 353         'people': people,
 354     })
 355
 356
 357 @login_required
 358 def book_owner(request, pk):
 359     doc = get_object_or_404(Document, pk=pk, deleted=False)
 360     if not doc.can_edit(request.user):
 361         return HttpResponseForbidden("Not authorized.")
 362
 363     error = ''
 364
 365     if request.method == 'POST':
 366         # TODO: real form
 367         new_org_pk = request.POST.get('owner_organization')
 368         if not new_org_pk:
 369             doc.owner_organization = None
 370             doc.owner_user = request.user
 371             doc.save()
 372         else:
 373             org = Organization.objects.get(pk=new_org_pk)
 374             if not org.is_member(request.user):
 375                 error = 'Bad organization'
 376             else:
 377                 doc.owner_organization = org
 378                 doc.owner_user = None
 379                 doc.save()
 380         if not error:
 381             return redirect('catalogue_user')
 382
 383     return render(request, 'catalogue/book_owner.html', {
 384         'doc': doc,
 385         'error': error,
 386     })
 387
 388
 389 @login_required
 390 def book_delete(request, pk):
 391     doc = get_object_or_404(Document, pk=pk, deleted=False)
 392     if not doc.can_edit(request.user):
 393         return HttpResponseForbidden("Not authorized.")
 394
 395     if request.method == 'POST':
 396         doc.deleted = True
 397         doc.save()
 398         return redirect('catalogue_user')
 399
 400     return render(request, 'catalogue/book_delete.html', {
 401         'doc': doc,
 402     })
 403
 404
 405 @require_POST
 406 @login_required
 407 def publish(request, pk):
 408     from wiki import forms
 409     from .models import PublishRecord
 410     from dvcs.models import Revision
 411
 412     doc = get_object_or_404(Document, pk=pk, deleted=False)
 413     if not doc.can_edit(request.user):
 414         return HttpResponseForbidden("Not authorized.")
 415     form = forms.DocumentTextPublishForm(request.POST, prefix="textpublish")
 416     if form.is_valid():
 417         rev = Revision.objects.get(pk=form.cleaned_data['revision'])
 418         # FIXME: check if in tree
 419         # if PublishRecord.objects.filter(revision=rev, document=doc).exists():
 420         #     return http.HttpResponse('exists')
 421         if not doc.published:
 422             site = Site.objects.get_current()
 423             send_notify_email(
 424                 'New published document in MIL/PEER',
 425                 '''New published document in MIL/PEER: %s. View it in browser: https://%s%s.
 426
 427 --
 428 MIL/PEER team.''' % (doc.meta()['title'], site.domain, reverse('catalogue_html', args=[doc.pk])))
 429         PublishRecord.objects.create(revision=rev, document=doc, user=request.user)
 430         doc.published = True
 431         doc.save()
 432         if request.is_ajax():
 433             return http.HttpResponse('ok')
 434         else:
 435             return redirect('catalogue_html', doc.pk)
 436     else:
 437         if request.is_ajax():
 438             return http.HttpResponse('error')
 439         else:
 440             try:
 441                 return redirect('catalogue_preview_rev', doc.pk, form.cleaned_data['revision'])
 442             except KeyError:
 443                 return redirect('catalogue_preview', doc.pk)
 444
 445
 446 @require_POST
 447 @login_required
 448 def unpublish(request, pk):
 449     doc = get_object_or_404(Document, pk=pk, deleted=False)
 450     if not doc.can_edit(request.user):
 451         return HttpResponseForbidden("Not authorized.")
 452
 453     doc.publish_log.all().delete()
 454     if request.is_ajax():
 455         return http.HttpResponse('ok')
 456     else:
 457         return redirect('catalogue_html', doc.pk)
 458
 459
 460 class GalleryMixin(object):
 461     def get_directory(self):
 462         # return "%s%s/" % (settings.IMAGE_DIR, 'org%d' % self.org.pk if self.org is not None else self.request.user.pk)
 463         return "uploads/%d/" % self.doc.pk
 464
 465
 466 class GalleryView(GalleryMixin, UploadView):
 467
 468     def breadcrumbs(self):
 469         return [
 470                 (self.doc.meta()['title'], '/documents/%d/' % self.doc.pk),
 471             ]
 472
 473     def get_object(self, request, pk=None):
 474         self.doc = Document.objects.get(pk=pk, deleted=False)
 475
 476
 477 @login_required
 478 def fork(request, pk):
 479     doc = get_object_or_404(Document, pk=pk, deleted=False)
 480     if request.method == "POST":
 481         form = forms.DocumentForkForm(request.POST, request.FILES)
 482         if form.is_valid():
 483             try:
 484                 org = request.user.membership_set.get(
 485                     organization=int(form.cleaned_data['owner_organization'])).organization
 486                 kwargs = {'owner_organization': org}
 487             except:
 488                 kwargs = {'owner_user': request.user}
 489
 490             new_doc = Document.objects.create(revision=doc.revision, **kwargs)
 491
 492             if os.path.isdir(settings.MEDIA_ROOT + "uploads/%d" % doc.pk):
 493                 shutil.copytree(
 494                     settings.MEDIA_ROOT + "uploads/%d" % doc.pk,
 495                     settings.MEDIA_ROOT + "uploads/%d" % new_doc.pk
 496                 )
 497
 498             new_doc.assigned_to = request.user
 499             new_doc.save()
 500
 501             return http.HttpResponseRedirect(reverse("wiki_editor", args=[new_doc.pk]))
 502     else:
 503         form = forms.DocumentForkForm()
 504
 505     return render(request, "catalogue/document_fork.html", {
 506         "form": form,
 507
 508         "logout_to": '/',
 509     })
 510
 511
 512 def upcoming(request):
 513     return render(request, "catalogue/upcoming.html", {
 514         'objects_list': Document.objects.filter(deleted=False).filter(publish_log=None),
 515     })
 516
 517
 518 def finished(request):
 519     return render(request, "catalogue/finished.html", {
 520         'objects_list': Document.objects.filter(deleted=False).exclude(publish_log=None),
 521     })