# -*- coding: utf-8 -*- import datetime import logging import os from django.apps import apps from django.contrib import messages from django.contrib.auth import login from django.contrib.auth.decorators import login_required from django.core.exceptions import PermissionDenied, SuspiciousOperation, FieldDoesNotExist from django.db.models import Q from django.forms import modelformset_factory from django.http import HttpResponse, HttpResponseRedirect from django.shortcuts import get_object_or_404 from django.urls import reverse, reverse_lazy from django.utils.decorators import method_decorator from django.utils.text import normalize_newlines from django.utils.translation import ugettext as _ from django.views import generic from .. import choices from .. import emails from .. import forms from .. import models from .. import signals from ..roles import get_users_by_role, has_role from ..workflow import DefaultWorkflow logger = logging.getLogger(__name__) class EventListView(generic.ListView): model = models.Event def get_queryset(self): user = self.request.user if user.is_superuser: qs = self.model.objects.all() elif has_role(user, 'manager_super'): qs = self.model.objects.all() else: filter = Q(owner=user) user_sports_list = list() for k in ('W', 'S', 'M', 'K', 'B'): role = 'manager_{}'.format(k.lower()) if has_role(user, role): user_sports_list.append(k) filter |= Q(sport__in=user_sports_list) if has_role(user, 'publisher'): filter |= Q(flags__status__code='accepted') if has_role(user, 'office'): filter |= Q(flags__status__code='submitted') qs = self.model.objects.filter(filter) return qs.order_by('-first_day', 'number') def get_context_data(self, **kwargs): context = super(EventListView, self).get_context_data(**kwargs) user = self.request.user context['has_permission_export'] = DefaultWorkflow.has_global_permission(user, 'export') return context @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): return super(EventListView, self).dispatch(request, *args, **kwargs) class EventListExportView(generic.FormView): form_class = forms.events.EventListExportForm template_name = 'dav_events/event_list_export_form.html' def form_valid(self, form): filename = _(u'Veranstaltungen') filter_kwargs = { 'flags__status__code': 'accepted', 'registration_closed': False, } if form.cleaned_data['sport']: sport = form.cleaned_data['sport'] filter_kwargs['sport__in'] = sport sport_labels = [u'%s' % choices.SPORT_CHOICES.get_label(code) for code in sport] filename += u'--%s' % u'_+_'.join(sport_labels) if form.cleaned_data['begin']: date = form.cleaned_data['begin'] filter_kwargs['first_day__gte'] = date filename += u'--%s' % date.strftime('%Y-%m-%d') if form.cleaned_data['end']: date = form.cleaned_data['end'] filter_kwargs['first_day__lte'] = date filename += u'--%s' % date.strftime('%Y-%m-%d') if form.cleaned_data['deadline']: deadline = form.cleaned_data['deadline'] else: deadline = None txt = u'' event_qs = models.Event.objects.filter(**filter_kwargs).order_by('first_day', 'number') for event in event_qs: if deadline and event.registration_required and event.deadline: if event.deadline < deadline: continue txt += normalize_newlines(event.render_as_text(format='ka-alpin')) if event.internal_note: txt += u'\n> Bearbeitungshinweis:\n> ' txt += normalize_newlines(event.internal_note).replace('\n', '\n> ') + u'\n' txt += u'\n' + (u'-' * 72) + '\n\n' filename += u'.txt' response = HttpResponse(txt, content_type='text/plain') response['Content-Disposition'] = 'attachment; filename="{filename}"'.format(filename=filename) return response @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): user = request.user if not DefaultWorkflow.has_global_permission(user, 'export'): raise PermissionDenied('export') return super(EventListExportView, self).dispatch(request, *args, **kwargs) class EventPermissionMixin(object): permission = 'view' def has_permission(self, permission, obj): user = self.request.user return obj.workflow.has_permission(user, permission) def enforce_permission(self, obj, permission=None): if permission is None: permission = self.permission if not self.has_permission(permission, obj): raise PermissionDenied(permission) class EventDetailView(EventPermissionMixin, generic.DetailView): model = models.Event def get_object(self, queryset=None): obj = super(EventDetailView, self).get_object(queryset=queryset) self.enforce_permission(obj) return obj def get_context_data(self, **kwargs): context = super(EventDetailView, self).get_context_data(**kwargs) obj = context.get('event') context['has_permission_submit'] = self.has_permission('submit', obj) context['has_permission_accept'] = self.has_permission('accept', obj) context['has_permission_publish'] = self.has_permission('publish', obj) context['has_permission_cancel'] = self.has_permission('cancel', obj) context['has_permission_realize'] = self.has_permission('realize', obj) context['has_permission_clear'] = self.has_permission('clear', obj) context['has_permission_update'] = self.has_permission('update', obj) context['is_submitted'] = obj.workflow.has_reached_status('submitted') context['is_accepted'] = obj.workflow.has_reached_status('accepted') context['is_publishing'] = obj.workflow.has_reached_status('publishing') context['is_publishing_any'] = obj.workflow.has_reached_status('publishing*') context['is_published'] = obj.workflow.has_reached_status('published') context['is_published_any'] = obj.workflow.has_reached_status('published*') context['is_started'] = obj.first_day <= datetime.date.today() context['is_expired'] = obj.workflow.has_reached_status('expired') context['is_canceled'] = obj.workflow.has_reached_status('canceled') context['is_realized'] = obj.workflow.has_reached_status('realized') context['is_cleared'] = obj.workflow.has_reached_status('cleared') return context @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): return super(EventDetailView, self).dispatch(request, *args, **kwargs) class EventRegistrationsView(EventPermissionMixin, generic.DetailView): model = models.Event template_name = 'dav_events/event_registrations.html' def get_form_kwargs(self, process_request=True): kwargs = {} if process_request and self.request.method in ('POST', 'PUT'): kwargs.update({ 'data': self.request.POST, 'files': self.request.FILES, }) if 'form_prefix' in self.request.POST: form_prefix = self.request.POST.get('form_prefix') kwargs['prefix'] = form_prefix pk_field = form_prefix + '-id' else: pk_field = 'id' if pk_field in self.request.POST: pk = self.request.POST.get(pk_field) event = self.object kwargs['instance'] = event.participants.get(pk=pk) return kwargs def get_participant_form(self, process_request=True): event = self.object form = forms.participant.ParticipantForm(**self.get_form_kwargs(process_request=process_request)) form.instance.event = event if not form.instance.position: form.instance.position = event.participants.count() + 1 return form def get_participant_formset(self): event = self.object ParticipantFormSet = modelformset_factory(models.Participant, form=forms.participant.ParticipantForm, extra=0) formset = ParticipantFormSet(queryset=event.participants.all()) return formset def get_context_data(self, **kwargs): context = super(EventRegistrationsView, self).get_context_data(**kwargs) event = context.get('event') context['has_permission_update'] = self.has_permission('update', event) context['has_permission_update_registration'] = self.has_permission('update-registration', event) context['has_permission_update_participants'] = self.has_permission('update-participants', event) context['has_permission_payment'] = self.has_permission('payment', event) context['is_published_any'] = event.workflow.has_reached_status('published*') context['is_expired'] = event.workflow.has_reached_status('expired') context['is_canceled'] = event.workflow.has_reached_status('canceled') context['is_realized'] = event.workflow.has_reached_status('realized') participants = event.participants.all() context['participants'] = participants participants_trash = event.trashed_participants.all() context['participants_trash'] = participants_trash earnings = 0 if event.charge: for participant in participants: if participant.paid: if participant.apply_reduced_fee: earnings += event.charge / 2 else: earnings += event.charge context['earnings'] = earnings if participants.count() > 1: email_list = [u'"{}" <{}>'.format(p.get_full_name(), p.email_address) for p in participants] email_list.sort() context['participant_emails'] = u', '.join(email_list) if 'participant_formset' not in context: context['participant_formset'] = self.get_participant_formset() if 'create_participant_form' not in context: context['create_participant_form'] = self.get_participant_form(process_request=False) registrations_support = hasattr(event, 'registrations') context['registrations_support'] = registrations_support if registrations_support: registrations_all = event.registrations.all() registrations_pending = registrations_all.filter(~Q(status__answered=True)) registrations_answered = registrations_all.filter(status__answered=True) context['registrations_all'] = registrations_all context['registrations_pending'] = registrations_pending context['registrations_answered'] = registrations_answered context['registrations'] = registrations_all return context def _close_registration(self, request, event): logger.info('Close registration: %s', event) event.registration_closed = True event.save(implicit_update=True) signals.event_registration_closed.send(sender=self.__class__, event=event, user=request.user) messages.success(request, _(u'Die Anmeldung wurde geschlossen')) def _reopen_registration(self, request, event): logger.info('Reopen registration: %s', event) event.registration_closed = False event.save(implicit_update=True) messages.success(request, _(u'Die Anmeldung wurde geöffnet')) def _kill_deadline(self, request, event): logger.info('Delete deadline: %s', event) event.deadline = None event.registration_closed = False event.save(implicit_update=True) messages.success(request, _(u'Der Anmeldeschluss wurde gelöscht')) def _accept_registration(self, request, registration): data = registration.get_data_dict() del data['created_at'] del data['answered_obsolete'] data['position'] = registration.event.participants.count() + 1 participant = models.Participant.objects.create(**data) registration.status.set_accepted() messages.success(request, _(u'Teilnehmer hinzugefügt: {}'.format(participant.get_full_name()))) def _reject_registration(self, registration): registration.status.set_rejected() def _reset_registration(self, registration): registration.status.reset() def _swap_participants_position(self, participant1, participant2): event = participant1.event pos_tmp = event.participants.count() + 1 pos1 = participant1.position pos2 = participant2.position participant1.position = pos_tmp participant1.save() participant2.position = pos1 participant2.save() participant1.position = pos2 participant1.save() def get(self, request, *args, **kwargs): self.object = self.get_object() self.enforce_permission(self.object, permission='view-participants') context = self.get_context_data(object=self.object) return self.render_to_response(context) def post(self, request, *args, **kwargs): self.object = self.get_object() event = self.object action = request.POST.get('action') if action == 'close-registration': self.enforce_permission(event, permission='update-registration') self._close_registration(request, event) elif action == 'open-registration': self.enforce_permission(event, permission='update-registration') self._reopen_registration(request, event) elif action == 'kill-deadline': self.enforce_permission(event, permission='update-registration') self._kill_deadline(request, event) elif action == 'accept_registration': self.enforce_permission(event, permission='update-participants') if hasattr(event, 'registrations'): registration_id = request.POST.get('registration') registration = event.registrations.get(id=registration_id) self._accept_registration(request, registration) else: raise FieldDoesNotExist('Event has no registrations') elif action == 'reject_registration': self.enforce_permission(event, permission='update-participants') if hasattr(event, 'registrations'): registration_id = request.POST.get('registration') registration = event.registrations.get(id=registration_id) self._reject_registration(registration) else: raise FieldDoesNotExist('Event has no registrations') elif action == 'untrash_registration': self.enforce_permission(event, permission='update-registration') if hasattr(event, 'registrations'): registration_id = request.POST.get('registration') registration = event.registrations.get(id=registration_id) self._reset_registration(registration) else: raise FieldDoesNotExist('Event has no registrations') elif action == 'toggle_reduced_fee': self.enforce_permission(event, permission='payment') participant_id = request.POST.get('id') participant = event.participants.get(id=participant_id) participant.apply_reduced_fee = not participant.apply_reduced_fee participant.save() elif action == 'confirm_payment': self.enforce_permission(event, permission='payment') participant_id = request.POST.get('id') participant = event.participants.get(id=participant_id) participant.paid = True participant.save() elif action == 'revoke_payment': self.enforce_permission(event, permission='payment') participant_id = request.POST.get('id') participant = event.participants.get(id=participant_id) participant.paid = False participant.save() elif action == 'trash_participant': self.enforce_permission(event, permission='update-participants') participant_id = request.POST.get('id') participant = event.participants.get(id=participant_id) participants_below = event.participants.filter(position__gt=participant.position) data = participant.get_data_dict() trashed = models.TrashedParticipant.objects.create(**data) participant.delete() for participant in participants_below: participant.position -= 1 participant.save() messages.success(request, _(u'Teilnehmer in den Papierkorb verschoben: {}'.format(trashed.get_full_name()))) elif action == 'untrash_participant': self.enforce_permission(event, permission='update-participants') trashed_id = request.POST.get('id') trashed = event.trashed_participants.get(id=trashed_id) trashed.position = event.participants.count() + 1 data = trashed.get_data_dict() del data['trashed_at'] participant = models.Participant.objects.create(**data) trashed.delete() messages.success(request, _(u'Teilnehmer zurückgeholt: {}'.format(participant.get_full_name()))) elif action == 'moveup_participant': self.enforce_permission(event, permission='update-participants') participant_id = request.POST.get('id') participant = event.participants.get(id=participant_id) current_position = participant.position if current_position > 1: upper_position = current_position - 1 upper_participant = event.participants.get(position=upper_position) self._swap_participants_position(participant, upper_participant) else: messages.error(request, 'Participant is already on first position') elif action == 'movedown_participant': self.enforce_permission(event, permission='update-participants') participant_id = request.POST.get('id') participant = event.participants.get(id=participant_id) current_position = participant.position if current_position < event.participants.count(): lower_position = current_position + 1 lower_participant = event.participants.get(position=lower_position) self._swap_participants_position(participant, lower_participant) else: messages.error(request, 'Participant is already on last position') elif action == 'update_participant': self.enforce_permission(event, permission='update-participants') form = self.get_participant_form() if form.is_valid(): form.save() participant = form.instance messages.success(request, _(u'Teilnehmer aktualisiert: {}'.format(participant.get_full_name()))) else: formset = self.get_participant_formset() for i in range(0, len(formset)): orig_form = formset.forms[i] if orig_form.prefix == form.prefix: formset.forms[i] = form messages.error(request, _(u'Ungültige Eingabe - Siehe unten')) return self.render_to_response(self.get_context_data(participant_formset=formset)) elif action == 'create_participant': self.enforce_permission(event, permission='update-participants') form = self.get_participant_form() if form.is_valid(): form.save() participant = form.instance messages.success(request, _(u'Teilnehmer hinzugefügt: {}'.format(participant.get_full_name()))) else: messages.error(request, _(u'Ungültige Eingabe - Siehe unten')) return self.render_to_response(self.get_context_data(create_participant_form=form)) else: messages.error(request, 'unsupported action: {}'.format(action)) return self.render_to_response(self.get_context_data()) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): return super(EventRegistrationsView, self).dispatch(request, *args, **kwargs) class RespondRegistrationView(EventPermissionMixin, generic.DetailView, generic.FormView): permission = 'update-participants' context_object_name = 'registration' template_name = 'dav_events/registration_response.html' form_class = forms.registration.RegistrationResponseForm def _accept_registration(self, request, registration): data = registration.get_data_dict() del data['created_at'] del data['answered_obsolete'] data['position'] = registration.event.participants.count() + 1 participant = models.Participant.objects.create(**data) registration.status.set_accepted() messages.success(request, _(u'Teilnehmer hinzugefügt: {}'.format(participant.get_full_name()))) def has_permission(self, permission, obj): user = self.request.user return obj.event.workflow.has_permission(user, permission) def get_queryset(self): model = apps.get_model(app_label='dav_registration', model_name='Registration') return model.objects.all() def get_success_url(self): return reverse('dav_events:registrations', args=[self.object.event.pk]) def get_initial(self): return { 'apply_reduced_fee': self.object.apply_reduced_fee, } def form_valid(self, form): registration = self.object registration.apply_reduced_fee = form.cleaned_data['apply_reduced_fee'] registration.save() self._accept_registration(self.request, registration) return HttpResponseRedirect(self.get_success_url()) def get(self, request, *args, **kwargs): self.object = self.get_object() self.enforce_permission(self.object) context = self.get_context_data(object=self.object) return self.render_to_response(context) def post(self, request, *args, **kwargs): self.object = self.get_object() self.enforce_permission(self.object) return super(RespondRegistrationView, self).post(request, *args, **kwargs) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): return super(RespondRegistrationView, self).dispatch(request, *args, **kwargs) class EventUpdateStatusView(EventPermissionMixin, generic.DetailView): model = models.Event def get(self, request, *args, **kwargs): status = kwargs.get('status') event = self.get_object() if status.startswith('submit'): if not self.has_permission('submit', event): raise PermissionDenied(status) elif status.startswith('accept'): if not self.has_permission('accept', event): raise PermissionDenied(status) elif status.startswith('publish'): if not self.has_permission('publish', event): raise PermissionDenied(status) elif status.startswith('cancel'): if not self.has_permission('cancel', event): raise PermissionDenied(status) elif status.startswith('realize'): if not self.has_permission('realize', event): raise PermissionDenied(status) elif status.startswith('clear'): if not self.has_permission('clear', event): raise PermissionDenied(status) else: if not self.has_permission('update', event): raise PermissionDenied(status) valid, return_code, message = event.workflow.validate_status_update(status) if not valid: if return_code == 'not-submitted': message = _(u'Veranstaltung ist noch nicht eingereicht.') elif return_code == 'not-accepted': message = _(u'Veranstaltung ist noch nicht freigegeben.') elif return_code == 'already-realized': message = _(u'Veranstaltung wurde bereits durchgeführt.') elif return_code == 'not-started': message = _(u'Veranstaltung hat noch nicht begonnen.') messages.error(request, message) return HttpResponseRedirect(event.get_absolute_url()) if not event.workflow.has_reached_status('publishing*') and not event.workflow.has_reached_status('published*'): cur_pub_date = event.planned_publication_date real_pub_date, real_pub_issue = event.workflow.plan_publication(event.first_day, event.deadline) if cur_pub_date != real_pub_date: if real_pub_date is None: real_pub_str = _(u'Unverzüglich') else: real_pub_str = u'%s (%s)' % (real_pub_date.strftime('%d.%m.%Y'), real_pub_issue) event.planned_publication_date = real_pub_date event.save() messages.warning(request, _(u'Veröffentlichungsdatum wurde angepasst: %s') % real_pub_str) event.workflow.update_status(status, request.user) if status.startswith('submit'): messages.success(request, _(u'Veranstaltung eingereicht.')) elif status.startswith('accept'): messages.success(request, _(u'Veranstaltung freigegeben.')) elif status.startswith('publish'): messages.success(request, _(u'Veröffentlichung registriert.')) elif status.startswith('cancel'): messages.success(request, _(u'Absage vermerkt.')) elif status.startswith('realize'): messages.success(request, _(u'Durchführung vermerkt.')) elif status.startswith('clear'): messages.success(request, _(u'Abrechnung vermerkt.')) else: messages.success(request, _(u'Veranstaltungsstatus registriert.')) return HttpResponseRedirect(event.get_absolute_url()) class EventUpdateView(EventPermissionMixin, generic.UpdateView): permission = 'update' model = models.Event form_class = forms.events.EventUpdateForm template_name_suffix = '_update_form' def get_object(self, queryset=None): obj = super(EventUpdateView, self).get_object(queryset=queryset) self.enforce_permission(obj) return obj def get_form(self, form_class=None): form = super(EventUpdateView, self).get_form(form_class) if not (self.has_permission('accept', self.object) or self.has_permission('publish', self.object)): form.fields['registration_howto'].disabled = True form.fields['planned_publication_date'].disabled = True form.fields['planned_publication_date'].widget = forms.generic.forms.HiddenInput() form.fields['number'].disabled = True form.fields['number'].widget = forms.generic.forms.HiddenInput() form.fields['owner'].disabled = True form.fields['owner'].widget = forms.generic.forms.HiddenInput() return form def get_context_data(self, **kwargs): context = super(EventUpdateView, self).get_context_data(**kwargs) obj = context.get('event') context['has_permission_accept'] = self.has_permission('accept', obj) context['has_permission_update'] = self.has_permission('update', obj) context['has_permission_publish'] = self.has_permission('publish', obj) context['is_accepted'] = obj.workflow.has_reached_status('accepted') context['is_publishing'] = obj.workflow.has_reached_status('publishing') context['is_publishing_any'] = obj.workflow.has_reached_status('publishing*') context['is_expired'] = obj.workflow.has_reached_status('expired') context['is_canceled'] = obj.workflow.has_reached_status('canceled') context['is_realized'] = obj.workflow.has_reached_status('realized') if 'form' in kwargs and kwargs['form'].errors: context['decollapseAllForms'] = True else: context['decollapseFirstForm'] = True return context def form_valid(self, form): form.instance.editor = self.request.user event = form.save() self.object = event if not event.workflow.has_reached_status('publishing*') and not event.workflow.has_reached_status('published*'): cur_pub_date = event.planned_publication_date real_pub_date, real_pub_issue = event.workflow.plan_publication(event.first_day, event.deadline) if cur_pub_date != real_pub_date: if real_pub_date is None: real_pub_str = _(u'Unverzüglich') else: real_pub_str = u'%s (%s)' % (real_pub_date.strftime('%d.%m.%Y'), real_pub_issue) event.planned_publication_date = real_pub_date event.save() messages.warning(self.request, _(u'Veröffentlichungsdatum wurde angepasst: %s') % real_pub_str) return HttpResponseRedirect(self.get_success_url()) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): return super(EventUpdateView, self).dispatch(request, *args, **kwargs) class EventCreateView(EventPermissionMixin, generic.FormView): form_class = forms.events.EventCreateForm template_dir = os.path.join('dav_events', 'event_create') default_template_name = 'default.html' abort_url = reverse_lazy('dav_events:root') def get_template_names(self): form = self.get_form() form_name = form.form_name template = os.path.join(self.template_dir, '{}.html'.format(form_name)) default_template = os.path.join(self.template_dir, self.default_template_name) return [ template, default_template ] def get_form_class(self, form_name=None): if form_name is not None: form_class = getattr(forms.events, form_name) elif 'dav_events_event_create_next_form_name' in self.request.session: form_name = self.request.session['dav_events_event_create_next_form_name'] form_class = getattr(forms.events, form_name) if not issubclass(form_class, self.form_class): raise SuspiciousOperation('Invalid next form: {}'.format(form_name)) else: base_form_class = self.form_class initial_form_name = base_form_class.get_initial_form_name() form_class = getattr(forms.events, initial_form_name) return form_class def get_form_kwargs(self): kwargs = super(EventCreateView, self).get_form_kwargs() if 'request' not in kwargs: kwargs['request'] = self.request return kwargs def get_context_data(self, **kwargs): context = super(EventCreateView, self).get_context_data(**kwargs) context['abort_url'] = self.abort_url return context def form_valid(self, form): event = form.get_instance() next_form_name = form.next_form_name if next_form_name: self.request.session['dav_events_event_create_next_form_name'] = next_form_name next_form_class = self.get_form_class(next_form_name) next_form = next_form_class(request=self.request) return self.render_to_response(self.get_context_data(form=next_form, event=event)) else: event.editor = self.request.user # Check for double submission (seems to happen accidentally if smartphone user reload the submit page) possible_doublets = models.Event.objects.filter(owner=event.owner, title=event.title, first_day=event.first_day) if possible_doublets.exists(): accident_period = datetime.datetime.now() - datetime.timedelta(hours=24) possible_doublets = possible_doublets.filter(created_at__gt=accident_period) if possible_doublets.exists(): doublet = possible_doublets.first() doublet_created_at = doublet.created_at.strftime('%d.%m.%Y %H:%M:%S') error_msg = _(u'Du hast bereits eine Veranstaltung' u' mit dem Titel "%(title)s"' u' für das Datum %(day)s angelegt' u' (am %(created_at)s).') % {'title': event.title, 'day': event.first_day, 'created_at': doublet_created_at} warn_msg = _(u'Deine eingegebenen Daten sind noch da,' u' wenn du jetzt auf "Neue Veranstaltung anlegen" klickst.' u' Du musst aber entweder den Titel oder das Startdatum ändern,' u' um die Veranstaltung anlegen zu können.') messages.error(self.request, error_msg) messages.warning(self.request, warn_msg) return HttpResponseRedirect(reverse('dav_events:list')) event.save() if 'submit' in form.data: event.workflow.update_status('submitted', event.owner) messages.success(self.request, _(u'Veranstaltung eingereicht.')) else: messages.success(self.request, _(u'Veranstaltung angelegt.')) form.flush_session_data() owner = event.owner self.clean_session_data() if self.request.user.is_authenticated: next_url = reverse('dav_events:list') if self.request.user != event.owner: messages.warning(self.request, u'%s %s' % ( _(u'Du hast jemand anderen als Tourenleiter eingetragen.'), _(u'Warum machst du sowas?') )) elif owner.last_login is None: login(self.request, owner) next_url = reverse('dav_auth:set_password') messages.success(self.request, _(u'Neuen Benutzer angemeldet: %(username)s') % {'username': owner.username}) messages.warning(self.request, _(u'Bitte neues Passwort setzen!')) else: next_url = reverse('dav_events:list') return HttpResponseRedirect(next_url) def clean_session_data(self, session=None): if session is None: session = self.request.session if 'dav_events_event_create_next_form_name' in session: del session['dav_events_event_create_next_form_name'] def get(self, request, *args, **kwargs): self.clean_session_data(request.session) if 'abort' in request.GET: form = self.get_form() form.flush_session_data() return HttpResponseRedirect(self.abort_url) elif 'copy' in request.GET: event = get_object_or_404(models.Event, pk=request.GET.get('copy')) if not self.has_permission('view', event): raise PermissionDenied('copy') for field in ('id', 'owner', 'created_at', 'number', 'charge', 'registration_howto', 'registration_closed', 'planned_publication_date', 'internal_note', ): if hasattr(event, field): setattr(event, field, None) initial_form_name = self.form_class.get_initial_form_name() form_class = getattr(forms.events, initial_form_name) form = form_class(request=self.request, instance=event) form.save_session_data() return super(EventCreateView, self).get(request, *args, **kwargs) def post(self, request, *args, **kwargs): return super(EventCreateView, self).post(request, *args, **kwargs)