292 lines
10 KiB
Python
292 lines
10 KiB
Python
from django.shortcuts import render, redirect, resolve_url
|
|
from django.views.generic.detail import DetailView, SingleObjectMixin, View
|
|
from django.views.generic.list import ListView, MultipleObjectMixin
|
|
from django.views.generic.edit import CreateView, FormView, UpdateView
|
|
from django.http import FileResponse, HttpResponse
|
|
from django.db import IntegrityError
|
|
from django.db.models import Q, Count
|
|
from django.utils.timezone import now
|
|
|
|
import json
|
|
|
|
from interface.views import EnsembleMixin, ProjectMixin
|
|
from interface.models import Project
|
|
from .models import Work, Document, Part, INSTRUMENTS
|
|
from . import forms, models
|
|
from .pdf_utils import extract_pages, extract_and_concat
|
|
|
|
class ProjectItemListView(ProjectMixin, ListView):
|
|
template_name = "library/item_list.html"
|
|
model = models.Item
|
|
|
|
def post(self, request, **kwargs):
|
|
|
|
project = self.get_project()
|
|
|
|
project_works = project.works.all()
|
|
|
|
instruments = request.POST.getlist('instruments')
|
|
works = request.POST.getlist('works')
|
|
|
|
self.request.session['part'] = request.POST.get('part', '')
|
|
self.request.session['instrument'] = request.POST.get('instrument')
|
|
|
|
valid_pks = [ x.pk for x in project_works ]
|
|
|
|
sections = []
|
|
|
|
for i, pk in enumerate(works):
|
|
|
|
if int(pk) not in valid_pks:
|
|
raise Exception(f"Not a valid work pk: {pk}")
|
|
|
|
tag = instruments[i]
|
|
if tag == '-':
|
|
continue
|
|
|
|
part = Part.objects.filter(tag=tag, doc__work=pk).select_related('doc').get()
|
|
sections.append((part.doc.upload.path, part.doc.work.name, part.start, part.end, 1))
|
|
|
|
result = extract_and_concat(sections)
|
|
|
|
download_name = f'{project.name}.pdf'
|
|
|
|
response = FileResponse(result, content_type="application/pdf")
|
|
response['Content-Disposition'] = f'inline; filename="{download_name}"'
|
|
return response
|
|
|
|
|
|
def get_queryset(self):
|
|
return super(ProjectItemListView, self).get_queryset().select_related('project', 'work')
|
|
|
|
def get_context_data(self, **kwargs):
|
|
data = super(ProjectItemListView, self).get_context_data(**kwargs)
|
|
data['instruments'] = INSTRUMENTS
|
|
data['instrument'] = self.request.session.get('instrument', 'Score')
|
|
data['part'] = self.request.session.get('part', '0')
|
|
return data
|
|
|
|
class ProjectItemManageView(ProjectMixin, ListView):
|
|
template_name = "library/item_list_manage.html"
|
|
model = models.Item
|
|
|
|
def post(self, request, **kwargs):
|
|
self.request = request
|
|
self.kwargs = kwargs
|
|
|
|
data = json.loads(request.body)
|
|
|
|
q = self.get_queryset()
|
|
for pk, order in data.items():
|
|
order = int(order)
|
|
if order == -1:
|
|
q.filter(pk=pk).delete()
|
|
else:
|
|
i = q.filter(pk=pk).update(order=order)
|
|
|
|
return HttpResponse(status=204)
|
|
|
|
def get_queryset(self):
|
|
return super(ProjectItemManageView, self).get_queryset().select_related('project', 'work')
|
|
|
|
class ProjectItemAddView(ProjectMixin, UpdateView):
|
|
form_class = forms.PlaylistAddForm
|
|
template_name = "interface/default_form.html"
|
|
|
|
def get_success_url(self):
|
|
return resolve_url('item_list_manage', project=self.kwargs['project'])
|
|
|
|
def get_object(self):
|
|
return self.get_project()
|
|
|
|
class WorkListView(EnsembleMixin, ListView):
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
#works = Work.objects.filter(collection__ensembles=self.request.ensemble_id).order_by('name').select_related('collection')
|
|
works = Work.objects.filter(collection__allowed_ensembles__ensemble=self.request.ensemble_id).order_by('name').select_related('collection')
|
|
|
|
loan_count = Count('project_items', Q(project_items__checkout__lte=now(), project_items__returned=None))
|
|
works = works.annotate(loan_count=loan_count)
|
|
|
|
q = self.request.GET.get('filter')
|
|
if q:
|
|
works = works.filter(Q(name__contains=q) | Q(composer__contains=q) | Q(tag_list__contains=q))
|
|
|
|
return works
|
|
|
|
class WorkAddView(EnsembleMixin, FormView):
|
|
template_name = "interface/default_form.html"
|
|
form_class = forms.WorkCreateForm
|
|
|
|
def get_form(self):
|
|
f = super(WorkAddView, self).get_form()
|
|
#qs = f.fields['orchestration'].queryset
|
|
#f.fields['orchestration'].queryset = qs.filter(ensemble_id__isnull=True) | qs.filter(ensemble_id=self.request.ensemble_id)
|
|
qs = f.fields['collection'].queryset
|
|
qs = qs.filter(administrators=self.request.user)
|
|
f.fields['collection'].queryset = qs
|
|
return f
|
|
|
|
def form_valid(self, form):
|
|
work = form.save(commit=False)
|
|
work.ensemble_id = self.request.ensemble_id
|
|
work.save()
|
|
|
|
# handle the files
|
|
uploads = self.request.FILES.getlist('uploads')
|
|
docs = []
|
|
for f in uploads:
|
|
docs.append(work.docs.create(upload=f).pk)
|
|
|
|
if len(docs) == 1:
|
|
return redirect('document_annotate', docs[0])
|
|
else:
|
|
return redirect('work_detail', pk=work.pk)
|
|
|
|
class WorkDetailView(EnsembleMixin, DetailView):
|
|
|
|
def get_queryset(self):
|
|
return Work.objects.filter(collection__allowed_ensembles__ensemble=self.request.ensemble_id)
|
|
|
|
class WorkAddToProject(EnsembleMixin, FormView):
|
|
form_class = forms.ProjectSelectForm
|
|
template_name = "interface/default_form.html"
|
|
title = "Select project to add work to"
|
|
|
|
def get_object(self):
|
|
return Work.objects.get(pk=self.kwargs['pk'])
|
|
|
|
def get_form(self):
|
|
f = super(WorkAddToProject, self).get_form()
|
|
qs = f.fields['project'].queryset
|
|
|
|
work = self.get_object()
|
|
qs = qs.filter(ensemble_id=self.request.ensemble_id).exclude(pk__in=work.projects.all())
|
|
|
|
f.fields['project'].queryset = qs
|
|
return f
|
|
|
|
def form_valid(self, form):
|
|
work = self.get_object()
|
|
project = form.cleaned_data['project']
|
|
work.project_items.create(project=project, approved_by=self.request.user, checkout=now())
|
|
return redirect('item_list', project=project.pk)
|
|
|
|
|
|
|
|
class WorkPartSetView(EnsembleMixin, DetailView):
|
|
template_name = "library/work_partset.html"
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
|
|
work = self.get_object()
|
|
|
|
parts = request.POST.getlist('parts')
|
|
copies = request.POST.getlist('copies')
|
|
|
|
sections = []
|
|
|
|
for i, tag in enumerate(parts):
|
|
part = work.parts.select_related('doc').get(tag=tag)
|
|
sections.append((part.doc.upload.path, part.instrument, part.start, part.end, int(copies[i])))
|
|
|
|
result = extract_and_concat(sections)
|
|
|
|
download_name = f'{work.name}.pdf'
|
|
|
|
response = FileResponse(result, content_type="application/pdf")
|
|
response['Content-Disposition'] = f'inline; filename="{download_name}"'
|
|
return response
|
|
|
|
def get_queryset(self):
|
|
return Version.objects.filter(work__ensemble_id=self.request.ensemble_id)
|
|
|
|
class DocumentDetailView(EnsembleMixin, DetailView):
|
|
|
|
def get_queryset(self):
|
|
return Document.objects.filter(work__ensemble=self.request.ensemble_id).select_related('work')
|
|
|
|
class DocumentAddView(EnsembleMixin, CreateView):
|
|
template_name = "interface/default_form.html"
|
|
model = Document
|
|
fields = ['upload']
|
|
|
|
def form_valid(self, form):
|
|
self.object = form.save(commit=False)
|
|
self.object.work_id = self.kwargs['pk']
|
|
self.object.save()
|
|
return redirect('document_annotate', self.object.pk)
|
|
|
|
class DocumentDownloadView(EnsembleMixin, SingleObjectMixin, View):
|
|
|
|
def get(self, request, **args):
|
|
self.request = request
|
|
self.args = args
|
|
self.object = self.get_object()
|
|
|
|
#response = FileResponse(self.object.upload, content_type="application/pdf")
|
|
#return response
|
|
return redirect(self.object.upload.url)
|
|
|
|
def get_queryset(self):
|
|
return Document.objects.filter(work__collection__allowed_ensembles__ensemble=self.request.ensemble_id)
|
|
|
|
class DocumentAnnotateView(EnsembleMixin, DetailView):
|
|
template_name = 'library/document_annotate.html'
|
|
|
|
def post(self, request, **args):
|
|
self.request = request
|
|
self.args = args
|
|
self.object = self.get_object()
|
|
|
|
data = json.loads(request.body)
|
|
|
|
tags = {}
|
|
for page, tag in data.items():
|
|
tags.setdefault(tag, []).append(int(page))
|
|
try:
|
|
del(tags['None'])
|
|
except KeyError:
|
|
pass
|
|
|
|
self.object.parts.all().delete()
|
|
for tag, pages in tags.items():
|
|
pages.sort()
|
|
end = pages[-1] if len(pages) > 1 else None
|
|
o = self.object.parts.create(tag=tag, start=pages[0], end=end)
|
|
|
|
return HttpResponse(status=204)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
data = super(DocumentAnnotateView, self).get_context_data(**kwargs)
|
|
|
|
pages = {}
|
|
for part in data['document'].parts.all():
|
|
for i in range(part.start, (part.end or part.start)+1):
|
|
pages[i] = part.tag
|
|
|
|
data['json_data'] = {'pageTags': pages, 'instruments': data['document'].work.orchestration}
|
|
return data
|
|
|
|
def get_queryset(self):
|
|
return Document.objects.filter(work__collection__allowed_ensembles__ensemble=self.request.ensemble_id).select_related('work')
|
|
|
|
|
|
class PartDownloadView(EnsembleMixin, SingleObjectMixin, View):
|
|
|
|
def get(self, request, **args):
|
|
self.request = request
|
|
self.args = args
|
|
self.object = self.get_object()
|
|
|
|
result = extract_pages(self.object.doc.upload.path, self.object.doc.work.name, self.object.start, self.object.end)
|
|
|
|
download_name = f'{self.object.doc.work.name}_{self.object.instrument}.pdf'
|
|
|
|
response = FileResponse(result, content_type="application/pdf")
|
|
response['Content-Disposition'] = f'inline; filename="foo.pdf"'
|
|
return response
|
|
|
|
def get_queryset(self):
|
|
return Part.objects.filter(doc__work__collection__allowed_ensembles__ensemble=self.request.ensemble_id).select_related('doc', 'doc__work') |