UPD: more registration staff on dav_events.

dav_events/views/events.py

@@ -5,7 +5,7 @@ import os
 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
+from django.core.exceptions import PermissionDenied, SuspiciousOperation, FieldDoesNotExist
 from django.db.models import Q
 from django.http import HttpResponse, HttpResponseRedirect
 from django.shortcuts import get_object_or_404
@@ -169,58 +169,130 @@ class EventRegistrationsView(EventPermissionMixin, generic.DetailView):
         self.enforce_permission(obj)
         return obj
 
+    def get_form_kwargs(self):
+        kwargs = {}
+        if self.request.method in ('POST', 'PUT'):
+            kwargs.update({
+                'data': self.request.POST,
+                'files': self.request.FILES,
+            })
+        return kwargs
+
+    def get_create_participant_form(self):
+        event = self.get_object()
+        form = forms.participant.ParticipantForm(**self.get_form_kwargs())
+        form.instance.event = event
+        form.instance.position = event.participants.count() + 1
+        return form
+
     def get_context_data(self, **kwargs):
         context = super(EventRegistrationsView, self).get_context_data(**kwargs)
-        obj = context.get('event')
-        context['has_permission_update'] = self.has_permission('update', obj)
-        context['is_published_any'] = obj.workflow.has_reached_status('published*')
-        context['is_done'] = obj.workflow.has_reached_status('expired')
+        event = context.get('event')
+        context['has_permission_update'] = self.has_permission('update', event)
+        context['is_published_any'] = event.workflow.has_reached_status('published*')
+        context['is_done'] = event.workflow.has_reached_status('expired')
 
-        class MockParticipant(object):
-            def __init__(self, id, name):
-                self.id = id
-                self.name = name
-
-            @property
-            def position(self):
-                return self.id
-
-            def get_full_name(self):
-                return self.name
-
-        participants = [MockParticipant(1, 'Erika Musterfrau'), MockParticipant(2, 'Max Mustermann')]
+        participants = event.participants.all()
         context['participants'] = participants
-
+        if hasattr(event, 'registrations'):
+            # registrations = event.registrations.filter(answered=False)
+            registrations = event.registrations.all()
+            context['registrations'] = registrations
+        if 'create_participant_form' not in context:
+            context['create_participant_form'] = self.get_create_participant_form()
         return context
 
-    def _send_mails(self, event, request):
-        editor = request.user
+    def _notify_publisher(self, event, editor):
         recipients = get_users_by_role('publisher')
         for recipient in recipients:
             if recipient.email:
                 email = emails.EventRegistrationClosedMail(recipient=recipient, event=event, editor=editor)
                 email.send()
 
+    def _close_registration(self, request, event):
+        logger.info('Close registration: %s', event)
+        event.registration_closed = True
+        event.save(implicit_update=True)
+        self._notify_publisher(event, 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):
+        event = registration.event
+
+        position = event.participants.count() + 1
+
+        data = {
+            'event': event,
+            'position': position,
+            'personal_names': registration.personal_names,
+            'family_names': registration.family_names,
+            'address': registration.address,
+            'postal_code': registration.postal_code,
+            'city': registration.city,
+            'email_address': registration.email_address,
+            'phone_number': registration.phone_number,
+            'dav_number': registration.dav_number,
+            'emergency_contact': registration.emergency_contact,
+            'experience': registration.experience,
+            'note': registration.note,
+            'purge_at': registration.purge_at,
+        }
+        participant = models.Participant.objects.create(**data)
+        registration.answered = True
+        registration.save()
+        messages.success(request, _(u'Teilnehmer hinzugefügt: {}'.format(participant.get_full_name())))
+
+    def _reject_registration(self, registration):
+        registration.answered = True
+        registration.save()
+
     def post(self, request, *args, **kwargs):
         event = self.get_object()
+        self.object = event
+
         action = request.POST.get('action')
         if action == 'close-registration':
-            logger.info('Close registration: %s', event)
-            event.registration_closed = True
-            event.save(implicit_update=True)
-            self._send_mails(event, request)
-            messages.success(request, _(u'Die Anmeldung wurde geschlossen'))
+            self._close_registration(request, event)
         elif action == 'open-registration':
-            logger.info('Reopen registration: %s', event)
-            event.registration_closed = False
-            event.save(implicit_update=True)
-            messages.success(request, _(u'Die Anmeldung wurde geöffnet'))
+            self._reopen_registration(request, event)
         elif action == 'kill-deadline':
-            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'))
+            self._kill_deadline(request, event)
+        elif action == 'accept_registration':
+            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':
+            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')
+        else:
+            form = self.get_create_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'irgendwas ging schief.'))
+                return self.render_to_response(self.get_context_data(create_participant_form=form))
         return HttpResponseRedirect(reverse('dav_events:registrations', kwargs={'pk': event.pk}))
 
     @method_decorator(login_required)