pretalx-musicrate/pretalx_musicrate/views.py

517 lines
17 KiB
Python

import csv
import re
from hmac import compare_digest
from urllib.parse import parse_qs, urlparse
from django.contrib import messages
from django.db.models import Case, FilteredRelation, Q, Value, When
from django.http import HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, redirect
from django.urls import reverse
from django.utils.functional import cached_property
from django.utils.html import Urlizer
from django.utils.translation import gettext_lazy as _, ngettext
from django.views.generic import FormView, TemplateView, View
from django.views.generic.detail import SingleObjectMixin
from django_context_decorator import context
from pretalx.common.views.mixins import EventPermissionRequired
from pretalx.orga.views.submission import BaseSubmissionList, SubmissionList
from pretalx.submission.models import Submission, SubmissionStates
from .forms import (
AssigneeForm,
EnhancedSubmissionFilterForm,
MusicrateSettingsForm,
RatingForm,
)
from .models import Juror, Rating
youtube_re = re.compile(
r"(?:https?://)?(youtu\.be/|(?:(?:m|www)\.)?youtube\.com/watch\?)", re.IGNORECASE
)
def get_last_submission(settings, submissions, submission=None):
if submission is not None and submission.state != SubmissionStates.SUBMITTED:
submission = None
submission = submission or settings.last_submission
if submission is not None and submission.state != SubmissionStates.SUBMITTED:
submission = None
submissions = submissions.filter(
submission_type__in=settings.submission_types.all(),
state=SubmissionStates.SUBMITTED,
)
if submission is not None and not submissions.filter(pk=submission.pk).exists():
submission = None
return submission or submissions.order_by("created").first()
class JoinView(TemplateView):
template_name = "pretalx_musicrate/join.html"
def validate_token(self, token):
try:
self.juror = Juror.objects.get(token=token)
return True
except Juror.DoesNotExist:
self.juror = None
if compare_digest(
token.encode("utf-8"),
self.request.event.pretalx_musicrate_settings.join_token.encode("utf-8"),
):
return True
messages.error(self.request, _("Invalid token"))
return False
def get_context_data(self, token_valid=False, **kwargs):
context = super().get_context_data(**kwargs)
context["juror"] = self.juror
context["token_valid"] = token_valid
return context
def get(self, request, *args, token, **kwargs):
token_valid = self.validate_token(token)
if self.juror is not None:
submission = get_last_submission(
self.request.event.pretalx_musicrate_settings,
self.request.event.submissions,
self.juror.last_submission,
)
if submission is not None:
return redirect(
"plugins:pretalx_musicrate:rating",
event=self.request.event.slug,
token=self.juror.token,
code=submission.code,
)
return super().get(request, *args, token_valid=token_valid, **kwargs)
def post(self, request, *args, token, **kwargs):
token_valid = self.validate_token(token)
if token_valid:
if self.juror is None:
self.juror = Juror.objects.create(
event=self.request.event,
last_submission=self.request.event.pretalx_musicrate_settings.last_submission,
)
submission = get_last_submission(
self.request.event.pretalx_musicrate_settings,
self.request.event.submissions,
self.juror.last_submission,
)
if submission is not None:
return redirect(
"plugins:pretalx_musicrate:rating",
event=self.request.event.slug,
token=self.juror.token,
code=submission.code,
)
return self.render_to_response(
self.get_context_data(token_valid=token_valid, **kwargs)
)
class MusicrateSettingsView(EventPermissionRequired, FormView):
permission_required = "orga.change_settings"
template_name = "pretalx_musicrate/settings.html"
form_class = MusicrateSettingsForm
def get_success_url(self):
return self.request.path
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
kwargs["event"] = self.request.event
return kwargs
def form_valid(self, form):
form.save()
messages.success(
self.request, _("The pretalx-musicrate settings were updated.")
)
return super().form_valid(form)
class QRCodeView(EventPermissionRequired, TemplateView):
permission_required = "orga.view_submissions"
template_name = "pretalx_musicrate/qrcode.html"
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["contents"] = self.request.build_absolute_uri(
reverse(
"plugins:pretalx_musicrate:join",
kwargs={
"event": self.request.event.slug,
"token": self.request.event.pretalx_musicrate_settings.join_token,
},
)
)
context["last_submission"] = get_last_submission(
self.request.event.pretalx_musicrate_settings,
self.request.event.submissions,
)
return context
class SubmissionMixin(SingleObjectMixin):
slug_field = "code"
slug_url_kwarg = "code"
def get_queryset(self):
return self.request.event.submissions.prefetch_related("answers").filter(
submission_type__in=self.request.event.pretalx_musicrate_settings.submission_types.all(),
state=SubmissionStates.SUBMITTED,
)
@context
@cached_property
def submission(self):
return self.get_object()
@context
@cached_property
def genre(self):
return (
self.submission.answers.filter(
question=self.request.event.pretalx_musicrate_settings.genre_question
)
.values_list("answer", flat=True)
.first()
)
@context
@cached_property
def origin(self):
return (
self.submission.answers.filter(
question=self.request.event.pretalx_musicrate_settings.origin_question
)
.values_list("answer", flat=True)
.first()
)
def get_url_kwargs(self, **kwargs):
return self.request.resolver_match.kwargs | kwargs
@cached_property
def index_queryset(self):
return (
self.get_queryset()
.prefetch_related(None)
.only("pk", "code")
.order_by("created")
)
@context
@cached_property
def prev(self):
if self.index == 1:
return None
return reverse(
self.request.resolver_match.view_name,
kwargs=self.get_url_kwargs(
code=self.index_queryset[self.index - 1 - 1].code
),
)
@context
@cached_property
def index(self):
return next(
map(
lambda s: s[0] + 1,
filter(
lambda s: s[1].pk == self.submission.pk,
enumerate(self.index_queryset),
),
)
)
@context
@cached_property
def count(self):
return self.index_queryset.count()
@context
@cached_property
def next(self):
if self.index == self.count:
return None
return reverse(
self.request.resolver_match.view_name,
kwargs=self.get_url_kwargs(
code=self.index_queryset[self.index - 1 + 1].code
),
)
class RatingView(FormView, SubmissionMixin):
template_name = "pretalx_musicrate/rating.html"
form_class = RatingForm
@cached_property
def juror(self):
return get_object_or_404(
Juror, token=self.request.resolver_match.kwargs["token"]
)
@context
@cached_property
def can_continue(self):
return self.submission.ratings.filter(juror=self.juror).exists()
def get_form(self, form_class=None):
if form_class is None:
form_class = self.get_form_class()
try:
instance = Rating.objects.get(submission=self.submission, juror=self.juror)
except Rating.DoesNotExist:
instance = None
return form_class(instance=instance, **self.get_form_kwargs())
def get_success_url(self):
return self.request.path
def form_valid(self, form):
obj = form.save(commit=False)
obj.submission = self.submission
obj.juror = self.juror
obj.save()
try:
self.juror.last_submission = self.submission
self.juror.save()
except Exception:
pass
messages.success(self.request, _("Saved!"))
return super().form_valid(form)
def get(self, request, *args, **kwargs):
self.object = self.get_object()
last_submission = get_last_submission(
self.request.event.pretalx_musicrate_settings,
self.request.event.submissions,
)
if (
last_submission is not None
and self.object.created > last_submission.created
):
return redirect(
self.request.resolver_match.view_name,
event=self.request.event.slug,
token=self.juror.token,
code=last_submission.code,
)
return super().get(request, *args, **kwargs)
class PresenterView(EventPermissionRequired, SubmissionMixin, TemplateView):
permission_required = "orga.view_submissions"
template_name = "pretalx_musicrate/present.html"
@context
@cached_property
def links(self):
class Extractor:
def __init__(self):
self.urls = []
def format(self, href, **kwargs):
self.urls.append(href)
return href
extractor = Extractor()
urlizer = Urlizer()
urlizer.url_template = extractor
urlizer(self.submission.abstract)
urlizer(self.submission.description)
urlizer(self.submission.notes)
urlizer(self.submission.internal_notes)
for answer in self.submission.answers.filter(
question__in=self.request.event.pretalx_musicrate_settings.link_questions.all()
).values_list("answer", flat=True):
urlizer(answer)
links = []
for url in extractor.urls:
if (m := youtube_re.search(url)) is not None:
links.append(
(
"youtube",
(
url.removeprefix("http")
.removeprefix("s")
.removeprefix("://")
.removeprefix("youtu.be/")[:11]
if m[1] == "youtu.be/"
else "".join(
parse_qs(urlparse(url).query).get("v", "dQw4w9WgXcQ")
)
),
)
)
else:
links.append(("other", url))
return links
@context
@property
def can_continue(self):
return True
def get(self, request, *args, **kwargs):
self.object = self.get_object()
settings = self.request.event.pretalx_musicrate_settings
last_submission = get_last_submission(settings, self.request.event.submissions)
if last_submission is None or self.object.created > last_submission.created:
try:
settings.last_submission = self.object
settings.save()
except Exception:
pass
response = super().get(request, *args, **kwargs)
response._csp_update = {"frame-src": "https://www.youtube-nocookie.com"}
return response
class MayAdvanceView(EventPermissionRequired, SubmissionMixin, View):
permission_required = "orga.view_submissions"
def get(self, request, *args, **kwargs):
num_ratings = self.submission.ratings.count()
num_jurors = self.request.event.jurors.count()
return JsonResponse(
{
"mayAdvance": num_ratings
>= round(
num_jurors
* self.request.event.pretalx_musicrate_settings.advance_threshold
)
and num_jurors > 2,
"statusText": ngettext(
"%(num_ratings)d of %(num_jurors)d has rated this submission",
"%(num_ratings)d of %(num_jurors)d have rated this submission",
num_ratings,
)
% {"num_jurors": num_jurors, "num_ratings": num_ratings},
}
)
class ExportView(EventPermissionRequired, View):
permission_required = "orga.view_submissions"
def get(self, request, *args, **kwargs):
response = HttpResponse(
content_type="text/csv",
headers={
"Content-Disposition": f'attachment; filename="{request.event.slug}.csv"'
},
)
writer = csv.writer(response)
genre_question = request.event.pretalx_musicrate_settings.genre_question
origin_question = request.event.pretalx_musicrate_settings.origin_question
jurors = request.event.jurors.order_by("token")
for submission in (
request.event.submissions.prefetch_related("answers")
.select_related("submission_type")
.filter(
submission_type__in=request.event.pretalx_musicrate_settings.submission_types.all(),
state=SubmissionStates.SUBMITTED,
)
.only("title", "submission_type__name")
.order_by("created")
):
submission_info = [submission.title, submission.submission_type.name]
if genre_question is not None:
submission_info.append(
submission.answers.filter(question=genre_question)
.values_list("answer", flat=True)
.first()
or ""
)
if origin_question is not None:
submission_info.append(
submission.answers.filter(question=origin_question)
.values_list("answer", flat=True)
.first()
or ""
)
writer.writerow(
[
*submission_info,
*jurors.annotate(
filtered_ratings=FilteredRelation(
"ratings", condition=Q(ratings__submission=submission)
),
rating=Case(
When(filtered_ratings__rating=None, then=Value("")),
When(filtered_ratings__rating="", then=Value("E")),
default="filtered_ratings__rating",
),
).values_list("rating", flat=True),
]
)
return response
class AssigneeView(EventPermissionRequired, FormView, SingleObjectMixin):
form_class = AssigneeForm
model = Submission
permission_required = "orga.change_submissions"
slug_field = "code"
slug_url_kwarg = "code"
template_name = "pretalx_musicrate/assignee.html"
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
kwargs["submission"] = self.object
return kwargs
def get_success_url(self):
return self.request.path
def form_valid(self, form):
form.save()
messages.success(self.request, _("Saved!"))
return super().form_valid(form)
def get(self, *args, **kwargs):
self.object = self.get_object()
return super().get(*args, **kwargs)
def post(self, *args, **kwargs):
self.object = self.get_object()
return super().post(*args, **kwargs)
class EnhancedSubmissionList(SubmissionList):
sortable_fields = ("code", "score__value", "title", "state", "assignee")
template_name = "pretalx_musicrate/enhanced_list.html"
def get_filter_form(self):
return EnhancedSubmissionFilterForm(
data=self.request.GET,
event=self.request.event,
usable_states=self.usable_states,
limit_tracks=self.limit_tracks,
search_fields=self.get_default_filters(),
)
def _get_base_queryset(self, for_review=False):
qs = (
super(BaseSubmissionList, self)
.get_queryset(for_review=for_review)
.prefetch_related("assignee")
.order_by("-id")
)
if not self.filter_form.is_valid():
return qs
return self.filter_form.filter_queryset(qs)