209 lines
7.4 KiB
Python
209 lines
7.4 KiB
Python
from camps.mixins import CampViewMixin
|
|
from django.contrib import messages
|
|
from django.http import Http404
|
|
from django.shortcuts import get_object_or_404, redirect
|
|
from django.urls import reverse
|
|
from django.views.generic.detail import SingleObjectMixin
|
|
from program.utils import (
|
|
add_existing_availability_to_matrix,
|
|
get_speaker_availability_form_matrix,
|
|
)
|
|
|
|
from . import models
|
|
|
|
|
|
class EnsureCFPOpenMixin(object):
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# do not permit this action if call for participation is not open
|
|
if not self.camp.call_for_participation_open:
|
|
messages.error(request, "The Call for Participation is not open.")
|
|
return redirect(
|
|
reverse("program:proposal_list", kwargs={"camp_slug": self.camp.slug})
|
|
)
|
|
|
|
# alright, continue with the request
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsureUnapprovedProposalMixin(SingleObjectMixin):
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# do not permit editing if the proposal is already approved
|
|
if (
|
|
self.get_object().proposal_status
|
|
== models.UserSubmittedModel.PROPOSAL_APPROVED
|
|
):
|
|
messages.error(
|
|
request,
|
|
"This proposal has already been approved. Please contact the organisers if you need to modify something.",
|
|
)
|
|
return redirect(
|
|
reverse("program:proposal_list", kwargs={"camp_slug": self.camp.slug})
|
|
)
|
|
|
|
# alright, continue with the request
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsureWritableCampMixin(object):
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# do not permit view if camp is in readonly mode
|
|
if self.camp.read_only:
|
|
messages.error(request, "No thanks")
|
|
return redirect(
|
|
reverse("program:proposal_list", kwargs={"camp_slug": self.camp.slug})
|
|
)
|
|
|
|
# alright, continue with the request
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsureUserOwnsProposalMixin(SingleObjectMixin):
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# make sure that this proposal belongs to the logged in user
|
|
if self.get_object().user.username != request.user.username:
|
|
messages.error(request, "No thanks")
|
|
return redirect(
|
|
reverse("program:proposal_list", kwargs={"camp_slug": self.camp.slug})
|
|
)
|
|
|
|
# alright, continue with the request
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class UrlViewMixin(object):
|
|
"""
|
|
Mixin with code shared between all the Url views
|
|
"""
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
"""
|
|
Check that we have a valid SpeakerProposal or EventProposal and that it belongs to the current user
|
|
"""
|
|
# get the proposal
|
|
if "event_uuid" in self.kwargs:
|
|
self.event_proposal = get_object_or_404(
|
|
models.EventProposal, uuid=self.kwargs["event_uuid"], user=request.user
|
|
)
|
|
elif "speaker_uuid" in self.kwargs:
|
|
self.speaker_proposal = get_object_or_404(
|
|
models.SpeakerProposal,
|
|
uuid=self.kwargs["speaker_uuid"],
|
|
user=request.user,
|
|
)
|
|
else:
|
|
# fuckery afoot
|
|
raise Http404
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
"""
|
|
Include the proposal in the template context
|
|
"""
|
|
context = super().get_context_data(**kwargs)
|
|
if hasattr(self, "event_proposal") and self.event_proposal:
|
|
context["event_proposal"] = self.event_proposal
|
|
else:
|
|
context["speaker_proposal"] = self.speaker_proposal
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
"""
|
|
Return to the detail view of the proposal
|
|
"""
|
|
if hasattr(self, "event_proposal"):
|
|
return self.event_proposal.get_absolute_url()
|
|
else:
|
|
return self.speaker_proposal.get_absolute_url()
|
|
|
|
|
|
class EventViewMixin(CampViewMixin):
|
|
"""
|
|
A mixin to get the Event object based on event_uuid in url kwargs
|
|
"""
|
|
|
|
def setup(self, *args, **kwargs):
|
|
super().setup(*args, **kwargs)
|
|
self.event = get_object_or_404(
|
|
models.Event, track__camp=self.camp, slug=self.kwargs["event_slug"]
|
|
)
|
|
|
|
def get_context_data(self, *args, **kwargs):
|
|
context = super().get_context_data(*args, **kwargs)
|
|
context["event"] = self.event
|
|
return context
|
|
|
|
|
|
class EventFeedbackViewMixin(EventViewMixin):
|
|
"""
|
|
A mixin to get the EventFeedback object based on self.event and self.request.user
|
|
"""
|
|
|
|
def setup(self, *args, **kwargs):
|
|
super().setup(*args, **kwargs)
|
|
self.event_feedback = get_object_or_404(
|
|
models.EventFeedback, event=self.event, user=self.request.user,
|
|
)
|
|
|
|
def get_object(self):
|
|
return self.event_feedback
|
|
|
|
|
|
class AvailabilityMatrixViewMixin(CampViewMixin):
|
|
"""
|
|
Mixin with shared code between all availability matrix views,
|
|
meaning all views that show an availability matrix (form or not)
|
|
for a SpeakerProposal or Speaker object. Used by SpeakerProposal
|
|
submitters and in backoffice.
|
|
"""
|
|
|
|
def setup(self, *args, **kwargs):
|
|
""" Get the availability matrix"""
|
|
super().setup(*args, **kwargs)
|
|
# do we have an Event or an EventProposal?
|
|
if hasattr(self.get_object(), "events"):
|
|
# we have an Event
|
|
event_types = models.EventType.objects.filter(
|
|
events__in=self.get_object().events.all()
|
|
).distinct()
|
|
else:
|
|
# we have an EventProposal
|
|
event_types = models.EventType.objects.filter(
|
|
event_proposals__in=self.get_object().event_proposals.all()
|
|
).distinct()
|
|
# get the matrix and add any existing availability to it
|
|
self.matrix = get_speaker_availability_form_matrix(
|
|
sessions=self.camp.event_sessions.filter(event_type__in=event_types)
|
|
)
|
|
add_existing_availability_to_matrix(self.matrix, self.get_object())
|
|
|
|
def get_form_kwargs(self):
|
|
""" Add the matrix to form kwargs, only used if the view has a form """
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["matrix"] = self.matrix
|
|
return kwargs
|
|
|
|
def get_initial(self, *args, **kwargs):
|
|
""" Populate the speaker_availability checkboxes, only used if the view has a form """
|
|
initial = super().get_initial(*args, **kwargs)
|
|
|
|
# add initial checkbox states
|
|
for date in self.matrix.keys():
|
|
# loop over daychunks and check if we need a checkbox
|
|
for daychunk in self.matrix[date].keys():
|
|
if not self.matrix[date][daychunk]:
|
|
# we have no event_session here, carry on
|
|
continue
|
|
if self.matrix[date][daychunk]["initial"] in [True, None]:
|
|
initial[self.matrix[date][daychunk]["fieldname"]] = True
|
|
else:
|
|
initial[self.matrix[date][daychunk]["fieldname"]] = False
|
|
|
|
# we are ready to render the form
|
|
return initial
|
|
|
|
def get_context_data(self, **kwargs):
|
|
""" Add the matrix to context """
|
|
context = super().get_context_data(**kwargs)
|
|
context["matrix"] = self.matrix
|
|
return context
|