696 lines
21 KiB
Python
696 lines
21 KiB
Python
import json
|
|
from io import BytesIO
|
|
|
|
from django.conf import settings
|
|
from django.contrib import messages
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.core.context_processors import csrf
|
|
from django.core.exceptions import ImproperlyConfigured, PermissionDenied
|
|
from django.core.urlresolvers import reverse
|
|
from django.http import HttpResponse, HttpResponseRedirect
|
|
from django.utils.decorators import method_decorator
|
|
from django.utils.translation import ugettext as _
|
|
from django.utils.translation import ugettext_lazy
|
|
from django.views import generic as django_views
|
|
from django.views.decorators.csrf import ensure_csrf_cookie
|
|
from reportlab.lib.units import cm
|
|
from reportlab.platypus import SimpleDocTemplate, Spacer
|
|
from rest_framework.response import Response
|
|
from rest_framework.views import APIView as _APIView
|
|
|
|
from .exceptions import OpenSlidesError
|
|
from .forms import CSVImportForm
|
|
from .pdf import firstPage, laterPages
|
|
from .signals import template_manipulation
|
|
from .utils import html_strong
|
|
|
|
View = django_views.View
|
|
|
|
|
|
class LoginMixin:
|
|
"""
|
|
Mixin for Views, that only can be viseted from users how are logedin.
|
|
"""
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, request, *args, **kwargs):
|
|
"""
|
|
Check if the user is loged in.
|
|
"""
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class PermissionMixin:
|
|
"""
|
|
Mixin for views, that only can be visited from users with special
|
|
permissions.
|
|
|
|
Set the attribute 'required_permission' to the required permission
|
|
string or override the method 'check_permission'.
|
|
"""
|
|
required_permission = None
|
|
|
|
def check_permission(self, request, *args, **kwargs):
|
|
"""
|
|
Checks if the user has the required permission.
|
|
"""
|
|
if self.required_permission is None:
|
|
return True
|
|
else:
|
|
return request.user.has_perm(self.required_permission)
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
"""
|
|
Check if the user has the permission.
|
|
|
|
If the user is not logged in, redirect the user to the login page.
|
|
"""
|
|
if not self.check_permission(request, *args, **kwargs):
|
|
if not request.user.is_authenticated():
|
|
path = request.get_full_path()
|
|
return HttpResponseRedirect(
|
|
"%s?next=%s" % (settings.LOGIN_URL, path))
|
|
else:
|
|
raise PermissionDenied
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class AjaxMixin:
|
|
"""
|
|
Mixin to response to an ajax request with an json object.
|
|
"""
|
|
|
|
def get_ajax_context(self, **context):
|
|
"""
|
|
Returns a dictonary with the context for the ajax response.
|
|
"""
|
|
return context
|
|
|
|
def ajax_get(self, request, *args, **kwargs):
|
|
"""
|
|
Deprecated. Use ajax_response instead.
|
|
"""
|
|
return self.ajax_response()
|
|
|
|
def ajax_response(self):
|
|
"""
|
|
Returns the HttpResponse.
|
|
"""
|
|
return HttpResponse(json.dumps(self.get_ajax_context()))
|
|
|
|
|
|
class ExtraContextMixin:
|
|
"""
|
|
Mixin to send the signal 'template_manipulation' to add extra content to the
|
|
context of the view.
|
|
|
|
For example this is used to add the main menu of openslides.
|
|
"""
|
|
|
|
def get_context_data(self, **kwargs):
|
|
"""
|
|
Sends the signal.
|
|
"""
|
|
context = super(ExtraContextMixin, self).get_context_data(**kwargs)
|
|
template_manipulation.send(
|
|
sender=type(self), request=self.request, context=context)
|
|
return context
|
|
|
|
|
|
class UrlMixin:
|
|
url_name_args = None
|
|
|
|
def get_url(self, url_name=None, url=None, args=None, use_absolute_url_link=None):
|
|
"""
|
|
Returns an url.
|
|
|
|
Tries
|
|
1. to use the reverse for the attribute 'url_name',
|
|
2. to use the attribute 'url' or
|
|
3. to use self.object.get_absolute_url().
|
|
|
|
Uses the attribute 'use_absolute_url_link' as argument for
|
|
get_absolute_url in the third step. If the attribute is 'None' then
|
|
the default value of get_absolute_url is used.
|
|
|
|
Raises ImproperlyConfigured if no url can be found.
|
|
"""
|
|
if url_name:
|
|
value = reverse(url_name, args=args or [])
|
|
elif url:
|
|
value = url
|
|
else:
|
|
if use_absolute_url_link is None:
|
|
get_absolute_url_args = []
|
|
else:
|
|
get_absolute_url_args = [use_absolute_url_link]
|
|
|
|
try:
|
|
value = self.object.get_absolute_url(*get_absolute_url_args)
|
|
except AttributeError:
|
|
raise ImproperlyConfigured(
|
|
'No url to redirect to. See openslides.utils.views.UrlMixin '
|
|
'for more details.')
|
|
return value
|
|
|
|
def get_url_name_args(self):
|
|
"""
|
|
Returns the arguments for the url name.
|
|
|
|
Default is an empty list or [self.object.pk] if this exist.
|
|
"""
|
|
if self.url_name_args is not None:
|
|
value = self.url_name_args
|
|
else:
|
|
try:
|
|
pk = self.object.pk
|
|
except AttributeError:
|
|
value = []
|
|
else:
|
|
value = [pk] if pk else []
|
|
return value
|
|
|
|
|
|
class SingleObjectMixin(django_views.detail.SingleObjectMixin):
|
|
"""
|
|
Mixin for single objects from the database.
|
|
"""
|
|
|
|
def dispatch(self, *args, **kwargs):
|
|
if not hasattr(self, 'object'):
|
|
# Save the object not only in the cache but in the public
|
|
# attribute self.object because Django expects this later.
|
|
# Because get_object() has an internal cache this line is not a
|
|
# performance problem.
|
|
self.object = self.get_object()
|
|
return super().dispatch(*args, **kwargs)
|
|
|
|
def get_object(self, *args, **kwargs):
|
|
"""
|
|
Returns the single object from database or cache.
|
|
"""
|
|
try:
|
|
obj = self._object
|
|
except AttributeError:
|
|
obj = super().get_object(*args, **kwargs)
|
|
self._object = obj
|
|
return obj
|
|
|
|
|
|
class FormMixin(UrlMixin):
|
|
"""
|
|
Mixin for views with forms.
|
|
"""
|
|
|
|
use_apply = True
|
|
success_url_name = None
|
|
success_url = None
|
|
success_message = None
|
|
apply_url_name = None
|
|
apply_url = None
|
|
error_message = ugettext_lazy('Please check the form for errors.')
|
|
|
|
def get_apply_url(self):
|
|
"""
|
|
Returns the url when the user clicks on 'apply'.
|
|
"""
|
|
return self.get_url(self.apply_url_name, self.apply_url,
|
|
args=self.get_url_name_args(),
|
|
use_absolute_url_link='update')
|
|
|
|
def get_success_url(self):
|
|
"""
|
|
Returns the url when the user submits a form.
|
|
|
|
Redirects to get_apply_url if self.use_apply is True
|
|
"""
|
|
if self.use_apply and 'apply' in self.request.POST:
|
|
value = self.get_apply_url()
|
|
else:
|
|
value = self.get_url(self.success_url_name, self.success_url,
|
|
args=self.get_url_name_args())
|
|
return value
|
|
|
|
def form_valid(self, form):
|
|
value = super(FormMixin, self).form_valid(form)
|
|
messages.success(self.request, self.get_success_message())
|
|
return value
|
|
|
|
def form_invalid(self, form):
|
|
value = super(FormMixin, self).form_invalid(form)
|
|
messages.error(self.request, self.get_error_message())
|
|
return value
|
|
|
|
def get_success_message(self):
|
|
return self.success_message
|
|
|
|
def get_error_message(self):
|
|
return self.error_message
|
|
|
|
|
|
class ModelFormMixin(FormMixin):
|
|
"""
|
|
Mixin for FormViews.
|
|
"""
|
|
|
|
def form_valid(self, form):
|
|
"""
|
|
Called if the form is valid.
|
|
|
|
1. saves the form into the model,
|
|
2. calls 'self.manipulate_object,
|
|
3. saves the object in the database,
|
|
4. calls self.post_save.
|
|
"""
|
|
self.object = form.save(commit=False)
|
|
self.manipulate_object(form)
|
|
self.object.save()
|
|
self.post_save(form)
|
|
messages.success(self.request, self.get_success_message())
|
|
return HttpResponseRedirect(self.get_success_url())
|
|
|
|
def manipulate_object(self, form):
|
|
"""
|
|
Called before the object is saved into the database.
|
|
"""
|
|
pass
|
|
|
|
def post_save(self, form):
|
|
"""
|
|
Called after the object is saved into the database.
|
|
"""
|
|
form.save_m2m()
|
|
|
|
|
|
class CSRFMixin:
|
|
"""
|
|
Adds the csrf cookie to the response.
|
|
"""
|
|
|
|
@classmethod
|
|
def as_view(cls, *args, **kwargs):
|
|
view = super().as_view(*args, **kwargs)
|
|
return ensure_csrf_cookie(view)
|
|
|
|
|
|
class TemplateView(PermissionMixin, ExtraContextMixin, django_views.TemplateView):
|
|
"""
|
|
View to return with an template.
|
|
"""
|
|
pass
|
|
|
|
|
|
class ListView(PermissionMixin, ExtraContextMixin, django_views.ListView):
|
|
"""
|
|
View to show a list of model objects.
|
|
"""
|
|
pass
|
|
|
|
|
|
class AjaxView(PermissionMixin, AjaxMixin, View):
|
|
"""
|
|
View for ajax requests.
|
|
|
|
Deprecated. Use APIView instead.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
# TODO: Raise an error, if the request is not an ajax-request
|
|
return self.ajax_response()
|
|
|
|
def post(self, *args, **kwargs):
|
|
return self.ajax_response()
|
|
|
|
|
|
class RedirectView(PermissionMixin, AjaxMixin, UrlMixin, django_views.RedirectView):
|
|
"""
|
|
View to redirect to another url.
|
|
|
|
The initial value of url_name_args is None, but the default given by
|
|
the used get_url_name_args method is [self.object.pk] if it exist, else
|
|
an empty list. Set url_name_args to an empty list, if you use an url
|
|
name which does not need any arguments.
|
|
"""
|
|
permanent = False
|
|
allow_ajax = False
|
|
url_name = None
|
|
|
|
def pre_redirect(self, request, *args, **kwargs):
|
|
"""
|
|
Called before the redirect.
|
|
"""
|
|
# TODO: Also call this method on post-request.
|
|
# Add pre_get_redirect for get requests.
|
|
pass
|
|
|
|
def pre_post_redirect(self, request, *args, **kwargs):
|
|
"""
|
|
Called before the redirect, if it is a post request.
|
|
"""
|
|
pass
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if request.method == 'GET':
|
|
self.pre_redirect(request, *args, **kwargs)
|
|
elif request.method == 'POST':
|
|
self.pre_post_redirect(request, *args, **kwargs)
|
|
|
|
if request.is_ajax() and self.allow_ajax:
|
|
return self.ajax_get(request, *args, **kwargs)
|
|
return super(RedirectView, self).get(request, *args, **kwargs)
|
|
|
|
def get_redirect_url(self, **kwargs):
|
|
"""
|
|
Returns the url to which the redirect should go.
|
|
"""
|
|
return self.get_url(self.url_name, self.url,
|
|
args=self.get_url_name_args())
|
|
|
|
|
|
class QuestionView(RedirectView):
|
|
"""
|
|
Mixin for questions to the requesting user.
|
|
|
|
The BaseView has to be a RedirectView.
|
|
"""
|
|
|
|
question_message = ugettext_lazy('Are you sure?')
|
|
final_message = ugettext_lazy('Thank you for your answer.')
|
|
answer_options = [('yes', ugettext_lazy("Yes")), ('no', ugettext_lazy("No"))]
|
|
question_url_name = None
|
|
question_url = None
|
|
|
|
def get_redirect_url(self, **kwargs):
|
|
"""
|
|
Returns the url to which the view should redirect.
|
|
"""
|
|
if self.request.method == 'GET':
|
|
url = self.get_url(self.question_url_name, self.question_url,
|
|
args=self.get_url_name_args())
|
|
else:
|
|
url = super(QuestionView, self).get_redirect_url()
|
|
return url
|
|
|
|
def pre_redirect(self, request, *args, **kwargs):
|
|
"""
|
|
Prints the question in a GET request.
|
|
"""
|
|
self.confirm_form()
|
|
|
|
def get_question_message(self):
|
|
"""
|
|
Returns the question.
|
|
"""
|
|
return str(self.question_message)
|
|
|
|
def get_answer_options(self):
|
|
"""
|
|
Returns the possible answers.
|
|
|
|
This is a list of tubles. The first element of the tuble is the key,
|
|
the second element is shown to the user.
|
|
"""
|
|
return self.answer_options
|
|
|
|
def confirm_form(self):
|
|
"""
|
|
Returns the form to show in the message.
|
|
"""
|
|
option_fields = "\n".join([
|
|
'<button type="submit" class="btn btn-mini" name="%s">%s</button>'
|
|
% (option[0], str(option[1]))
|
|
for option in self.get_answer_options()])
|
|
messages.warning(
|
|
self.request,
|
|
'%(message)s<form action="%(url)s" method="post">'
|
|
'<input type="hidden" value="%(csrf)s" name="csrfmiddlewaretoken">'
|
|
'%(option_fields)s</form>' % {
|
|
'message': self.get_question_message(),
|
|
'url': self.request.path,
|
|
'csrf': csrf(self.request)['csrf_token'],
|
|
'option_fields': option_fields})
|
|
|
|
def pre_post_redirect(self, request, *args, **kwargs):
|
|
"""
|
|
Calls the method for the answer the user clicked.
|
|
|
|
The method name is on_clicked_ANSWER where ANSWER is the key from
|
|
the clicked answer. See get_answer_options. Prints an error
|
|
message, if no valid answer was given. If this method is not
|
|
defined, nothing happens, else it is called and the success message
|
|
is printed to the user.
|
|
"""
|
|
try:
|
|
answer = self.get_answer()
|
|
except OpenSlidesError as error:
|
|
messages.error(self.request, error)
|
|
else:
|
|
method_name = 'on_clicked_%s' % answer
|
|
method = getattr(self, method_name, None)
|
|
if method is None:
|
|
pass
|
|
else:
|
|
method()
|
|
self.create_final_message()
|
|
|
|
def get_answer(self):
|
|
"""
|
|
Returns the key of the clicked answer.
|
|
|
|
Raises OpenSlidesError if the answer is not one of get_answer_options.
|
|
"""
|
|
for option_key, option_name in self.get_answer_options():
|
|
if option_key in self.request.POST:
|
|
answer = option_key
|
|
break
|
|
else:
|
|
raise OpenSlidesError(ugettext_lazy('You did not send a valid answer.'))
|
|
return answer
|
|
|
|
def get_final_message(self):
|
|
"""
|
|
Returns the message to show after the action.
|
|
|
|
Uses the attribute 'final_messsage' as default
|
|
"""
|
|
return self.final_message
|
|
|
|
def create_final_message(self):
|
|
"""
|
|
Creates a message.
|
|
"""
|
|
messages.success(self.request, self.get_final_message())
|
|
|
|
|
|
class FormView(PermissionMixin, ExtraContextMixin, FormMixin,
|
|
django_views.FormView):
|
|
"""
|
|
View for forms.
|
|
"""
|
|
pass
|
|
|
|
|
|
class UpdateView(PermissionMixin, ExtraContextMixin,
|
|
ModelFormMixin, SingleObjectMixin, django_views.UpdateView):
|
|
"""
|
|
View to update an model object.
|
|
"""
|
|
|
|
def get_success_message(self):
|
|
if self.success_message is None:
|
|
message = _('%s was successfully modified.') % html_strong(self.get_object())
|
|
else:
|
|
message = self.success_message
|
|
return message
|
|
|
|
|
|
class CreateView(PermissionMixin, ExtraContextMixin,
|
|
ModelFormMixin, django_views.CreateView):
|
|
"""
|
|
View to create a model object.
|
|
|
|
Note: This class has a django method get_object() which is different form
|
|
the method in openslides.utils.views.SingleObjectMixin. The result
|
|
is not cached.
|
|
"""
|
|
|
|
def get_success_message(self):
|
|
if self.success_message is None:
|
|
message = _('%s was successfully created.') % html_strong(self.object)
|
|
else:
|
|
message = self.success_message
|
|
return message
|
|
|
|
|
|
class DeleteView(SingleObjectMixin, QuestionView):
|
|
"""
|
|
View to delete an model object.
|
|
"""
|
|
success_url = None
|
|
success_url_name = None
|
|
|
|
def get_redirect_url(self, **kwargs):
|
|
"""
|
|
Returns the url on which the delete dialog is shown and the url after
|
|
the deleting.
|
|
|
|
On GET-requests and on aborted or failed POST-requests, redirects to the detail
|
|
view as default. The attributes question_url_name or question_url can
|
|
define other urls.
|
|
"""
|
|
if self.request.method == 'POST':
|
|
try:
|
|
answer = self.get_answer()
|
|
except OpenSlidesError:
|
|
answer = 'no'
|
|
if answer == 'no':
|
|
url = self.get_url(self.question_url_name, self.question_url,
|
|
args=self.get_url_name_args())
|
|
else:
|
|
url = self.get_url(self.success_url_name, self.success_url,
|
|
args=self.get_url_name_args())
|
|
else:
|
|
url = self.get_url(self.question_url_name, self.question_url,
|
|
args=self.get_url_name_args())
|
|
return url
|
|
|
|
def get_question_message(self):
|
|
"""
|
|
Returns the question for the delete dialog.
|
|
"""
|
|
return _('Do you really want to delete %s?') % html_strong(self.get_object())
|
|
|
|
def on_clicked_yes(self):
|
|
"""
|
|
Deletes the object.
|
|
"""
|
|
self.get_object().delete()
|
|
|
|
def get_final_message(self):
|
|
"""
|
|
Prints the success message to the user.
|
|
"""
|
|
return _('%s was successfully deleted.') % html_strong(self.get_object())
|
|
|
|
|
|
class DetailView(PermissionMixin, ExtraContextMixin, SingleObjectMixin, django_views.DetailView):
|
|
"""
|
|
View to show an model object.
|
|
"""
|
|
pass
|
|
|
|
|
|
class PDFView(PermissionMixin, View):
|
|
"""
|
|
View to generate an PDF.
|
|
"""
|
|
|
|
filename = ugettext_lazy('undefined-filename')
|
|
top_space = 3
|
|
document_title = None
|
|
|
|
def get_top_space(self):
|
|
return self.top_space
|
|
|
|
def get_document_title(self):
|
|
if self.document_title:
|
|
return str(self.document_title)
|
|
else:
|
|
return ''
|
|
|
|
def get_filename(self):
|
|
return self.filename
|
|
|
|
def get_template(self, buffer):
|
|
return SimpleDocTemplate(buffer)
|
|
|
|
def build_document(self, pdf_document, story):
|
|
pdf_document.build(
|
|
story, onFirstPage=firstPage, onLaterPages=laterPages)
|
|
|
|
def render_to_response(self, filename):
|
|
response = HttpResponse(content_type='application/pdf')
|
|
filename = 'filename=%s.pdf;' % self.get_filename()
|
|
response['Content-Disposition'] = filename.encode('utf-8')
|
|
|
|
buffer = BytesIO()
|
|
pdf_document = self.get_template(buffer)
|
|
pdf_document.title = self.get_document_title()
|
|
story = [Spacer(1, self.get_top_space() * cm)]
|
|
|
|
self.append_to_pdf(story)
|
|
|
|
self.build_document(pdf_document, story)
|
|
|
|
pdf = buffer.getvalue()
|
|
buffer.close()
|
|
response.write(pdf)
|
|
return response
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
return self.render_to_response(self.get_filename())
|
|
|
|
|
|
class CSVImportView(FormView):
|
|
"""
|
|
View for a csv import of some data.
|
|
|
|
The attribute import_function might to be a staticmethod.
|
|
"""
|
|
form_class = CSVImportForm
|
|
import_function = None
|
|
|
|
def get_import_function(self):
|
|
"""
|
|
Override this to return a specific function to import data from
|
|
a given csv file using some extra kwargs. This function has to
|
|
return a three-tuple of strings which are the messages for the
|
|
user.
|
|
|
|
Example function:
|
|
|
|
def my_import(csvfile, **kwargs):
|
|
# Parse file and import data
|
|
return success_message, warning_message, error_message
|
|
"""
|
|
if self.import_function is None:
|
|
raise NotImplementedError('A CSVImportView must provide an import_function '
|
|
'attribute or override a get_import_function method.')
|
|
return self.import_function
|
|
|
|
def form_valid(self, form):
|
|
success, warning, error = self.get_import_function()(**form.cleaned_data)
|
|
messages.success(self.request, success)
|
|
messages.warning(self.request, warning)
|
|
messages.error(self.request, error)
|
|
return super(CSVImportView, self).form_valid(form)
|
|
|
|
|
|
class APIView(_APIView):
|
|
"""
|
|
The Django Rest framework APIView with improvements for OpenSlides.
|
|
"""
|
|
|
|
http_method_names = []
|
|
"""
|
|
The allowed actions have to be explicitly defined.
|
|
|
|
Django allowes the following:
|
|
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']
|
|
"""
|
|
|
|
def get_context_data(self, **context):
|
|
"""
|
|
Returns the context for the response.
|
|
"""
|
|
return context
|
|
|
|
def method_call(self, request, *args, **kwargs):
|
|
"""
|
|
Http method that returns the response object with the context data.
|
|
"""
|
|
return Response(self.get_context_data())
|
|
|
|
# Add the http-methods and delete the method "method_call"
|
|
get = post = put = patch = delete = head = options = trace = method_call
|
|
del method_call
|