Fix #515 -- Add check-in lists (#693)

* Data model and migration

* Some backwards compatibility

* CRUD for checkin lists

* Show and perform checkins

* Correct numbers in table and dashboard widget

* event creation and cloning

* Allow to link specific exports and pass options per query

* Play with the CSV export

* PDF export

* Collapse exports by default

* Improve PDF exporter

* Addon stuff

* Subevent stuff, pretixdroid tests

* pretixdroid tests

* Add CRUD API

* Test compatibility

* Fix test

* DB-independent sorting behavior

* Add CRUD and coyp tests

* Re-enable pretixdroid plugin

* pretixdroid config

* Tests & fixes

src/pretix/control/views/checkin.py

@@ -1,122 +1,221 @@
+import dateutil.parser
 from django.contrib import messages
 from django.core.urlresolvers import reverse
-from django.db.models import F, Prefetch, Q
-from django.db.models.functions import Coalesce
-from django.shortcuts import redirect
-from django.utils.timezone import now
+from django.db import transaction
+from django.db.models import Max, OuterRef, Subquery
+from django.http import Http404, HttpResponseRedirect
+from django.shortcuts import get_object_or_404, redirect
+from django.utils.functional import cached_property
+from django.utils.timezone import make_aware, now
 from django.utils.translation import ugettext_lazy as _
-from django.views.generic import ListView
+from django.views.generic import DeleteView, ListView
+from pytz import UTC
 
-from pretix.base.models import Checkin, Item, Order, OrderPosition
+from pretix.base.models import Checkin, Order, OrderPosition
+from pretix.base.models.checkin import CheckinList
+from pretix.control.forms.checkin import CheckinListForm
+from pretix.control.forms.filter import CheckInFilterForm
 from pretix.control.permissions import EventPermissionRequiredMixin
+from pretix.control.views import CreateView, UpdateView
 
 
-class CheckInView(EventPermissionRequiredMixin, ListView):
+class CheckInListShow(EventPermissionRequiredMixin, ListView):
     model = Checkin
     context_object_name = 'entries'
     paginate_by = 30
     template_name = 'pretixcontrol/checkin/index.html'
     permission = 'can_view_orders'
 
-    def get_queryset(self):
+    def get_queryset(self, filter=True):
+        cqs = Checkin.objects.filter(
+            position_id=OuterRef('pk'),
+            list_id=self.list.pk
+        ).order_by().values('position_id').annotate(
+            m=Max('datetime')
+        ).values('m')
 
-        qs = OrderPosition.objects.filter(order__event=self.request.event, order__status='p')
+        qs = OrderPosition.objects.filter(
+            order__event=self.request.event,
+            order__status=Order.STATUS_PAID,
+            subevent=self.list.subevent
+        ).annotate(
+            last_checked_in=Subquery(cqs)
+        ).select_related('item', 'variation', 'order', 'addon_to')
 
-        # if this setting is False, we check only items for admission
-        if not self.request.event.settings.ticket_download_nonadm:
-            qs = qs.filter(item__admission=True)
+        if not self.list.all_products:
+            qs = qs.filter(item__in=self.list.limit_products.values_list('id', flat=True))
 
-        if self.request.GET.get("status", "") != "":
-            p = self.request.GET.get("status", "")
-            if p == '1':
-                # records with check-in record
-                qs = qs.filter(checkins__isnull=False)
-            elif p == '0':
-                qs = qs.filter(checkins__isnull=True)
+        if filter and self.filter_form.is_valid():
+            qs = self.filter_form.filter_qs(qs)
 
-        if self.request.GET.get("user", "") != "":
-            u = self.request.GET.get("user", "")
-            qs = qs.filter(
-                Q(order__email__icontains=u) | Q(attendee_name__icontains=u) | Q(attendee_email__icontains=u)
-            )
+        return qs
 
-        if self.request.GET.get("item", "") != "":
-            u = self.request.GET.get("item", "")
-            qs = qs.filter(item_id=u)
+    @cached_property
+    def filter_form(self):
+        return CheckInFilterForm(
+            data=self.request.GET,
+            event=self.request.event,
+            list=self.list
+        )
 
-        if self.request.GET.get("subevent", "") != "":
-            s = self.request.GET.get("subevent", "")
-            qs = qs.filter(subevent_id=s)
-
-        qs = qs.prefetch_related(
-            Prefetch('checkins', queryset=Checkin.objects.filter(position__order__event=self.request.event))
-        ).select_related('order', 'item', 'addon_to')
-
-        if self.request.GET.get("ordering", "") != "":
-            p = self.request.GET.get("ordering", "")
-            keys_allowed = self.get_ordering_keys_mappings()
-            if p in keys_allowed:
-                mapped_field = keys_allowed[p]
-                if isinstance(mapped_field, dict):
-                    order = mapped_field.pop('_order')
-                    qs = qs.annotate(**mapped_field).order_by(order)
-                elif isinstance(mapped_field, (list, tuple)):
-                    qs = qs.order_by(*mapped_field)
-                else:
-                    qs = qs.order_by(mapped_field)
-
-        return qs.distinct()
+    def dispatch(self, request, *args, **kwargs):
+        self.list = get_object_or_404(self.request.event.checkin_lists.all(), pk=kwargs.get("list"))
+        return super().dispatch(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
         ctx = super().get_context_data(**kwargs)
-        ctx['items'] = Item.objects.filter(event=self.request.event)
-        ctx['filtered'] = ("status" in self.request.GET or "user" in self.request.GET or "item" in self.request.GET
-                           or "subevent" in self.request.GET)
+        ctx['checkinlist'] = self.list
+        ctx['filter_form'] = self.filter_form
+        for e in ctx['entries']:
+            if e.last_checked_in:
+                if isinstance(e.last_checked_in, str):
+                    # Apparently only happens on SQLite
+                    e.last_checked_in_aware = make_aware(dateutil.parser.parse(e.last_checked_in), UTC)
+                else:
+                    e.last_checked_in_aware = e.last_checked_in
         return ctx
 
     def post(self, request, *args, **kwargs):
-        positions = OrderPosition.objects.select_related('item', 'variation', 'order', 'addon_to').filter(
-            order__event=self.request.event,
+        if "can_change_orders" not in request.eventpermset:
+            messages.error(request, _('You do not have permission to perform this action.'))
+            return redirect(reverse('control:event.orders.checkins', kwargs={
+                'event': self.request.event.slug,
+                'organizer': self.request.event.organizer.slug
+            }) + '?' + request.GET.urlencode())
+
+        positions = self.get_queryset(filter=False).filter(
             pk__in=request.POST.getlist('checkin')
         )
 
         for op in positions:
             created = False
             if op.order.status == Order.STATUS_PAID:
-                ci, created = Checkin.objects.get_or_create(position=op, defaults={
+                ci, created = Checkin.objects.get_or_create(position=op, list=self.list, defaults={
                     'datetime': now(),
                 })
             op.order.log_action('pretix.control.views.checkin', data={
                 'position': op.id,
                 'positionid': op.positionid,
                 'first': created,
-                'datetime': now()
+                'datetime': now(),
+                'list': self.list.pk
             }, user=request.user)
 
         messages.success(request, _('The selected tickets have been marked as checked in.'))
-        return redirect(reverse('control:event.orders.checkins', kwargs={
+        return redirect(reverse('control:event.orders.checkinlists.show', kwargs={
             'event': self.request.event.slug,
-            'organizer': self.request.event.organizer.slug
+            'organizer': self.request.event.organizer.slug,
+            'list': self.list.pk
         }) + '?' + request.GET.urlencode())
 
-    @staticmethod
-    def get_ordering_keys_mappings():
-        return {
-            'code': 'order__code',
-            '-code': '-order__code',
-            'email': 'order__email',
-            '-email': '-order__email',
-            # Set nulls_first to be consistent over databases
-            'status': F('checkins__id').asc(nulls_first=True),
-            '-status': F('checkins__id').desc(nulls_last=True),
-            'timestamp': F('checkins__datetime').asc(nulls_first=True),
-            '-timestamp': F('checkins__datetime').desc(nulls_last=True),
-            'item': ('item__name', 'variation__value'),
-            '-item': ('-item__name', 'variation__value'),
-            'subevent': ('subevent__date_from', 'subevent__name'),
-            '-subevent': ('-subevent__date_from', '-subevent__name'),
-            'name': {'_order': F('display_name').asc(nulls_first=True),
-                     'display_name': Coalesce('attendee_name', 'addon_to__attendee_name')},
-            '-name': {'_order': F('display_name').desc(nulls_last=True),
-                      'display_name': Coalesce('attendee_name', 'addon_to__attendee_name')},
-        }
+
+class CheckinListList(EventPermissionRequiredMixin, ListView):
+    model = CheckinList
+    context_object_name = 'checkinlists'
+    paginate_by = 30
+    permission = 'can_view_orders'
+    template_name = 'pretixcontrol/checkin/lists.html'
+
+    def get_queryset(self):
+        qs = self.request.event.checkin_lists.prefetch_related("limit_products")
+        qs = CheckinList.annotate_with_numbers(qs, self.request.event)
+
+        if self.request.GET.get("subevent", "") != "":
+            s = self.request.GET.get("subevent", "")
+            qs = qs.filter(subevent_id=s)
+        return qs
+
+
+class CheckinListCreate(EventPermissionRequiredMixin, CreateView):
+    model = CheckinList
+    form_class = CheckinListForm
+    template_name = 'pretixcontrol/checkin/list_edit.html'
+    permission = 'can_change_event_settings'
+    context_object_name = 'checkinlist'
+
+    def get_success_url(self) -> str:
+        return reverse('control:event.orders.checkinlists', kwargs={
+            'organizer': self.request.event.organizer.slug,
+            'event': self.request.event.slug,
+        })
+
+    @transaction.atomic
+    def form_valid(self, form):
+        form.instance.event = self.request.event
+        messages.success(self.request, _('The new check-in list has been created.'))
+        ret = super().form_valid(form)
+        form.instance.log_action('pretix.event.checkinlist.added', user=self.request.user,
+                                 data=dict(form.cleaned_data))
+        return ret
+
+    def form_invalid(self, form):
+        messages.error(self.request, _('We could not save your changes. See below for details.'))
+        return super().form_invalid(form)
+
+
+class CheckinListUpdate(EventPermissionRequiredMixin, UpdateView):
+    model = CheckinList
+    form_class = CheckinListForm
+    template_name = 'pretixcontrol/checkin/list_edit.html'
+    permission = 'can_change_event_settings'
+    context_object_name = 'checkinlist'
+
+    def get_object(self, queryset=None) -> CheckinList:
+        try:
+            return self.request.event.checkin_lists.get(
+                id=self.kwargs['list']
+            )
+        except CheckinList.DoesNotExist:
+            raise Http404(_("The requested list does not exist."))
+
+    @transaction.atomic
+    def form_valid(self, form):
+        messages.success(self.request, _('Your changes have been saved.'))
+        if form.has_changed():
+            self.object.log_action(
+                'pretix.event.checkinlist.changed', user=self.request.user, data={
+                    k: form.cleaned_data.get(k) for k in form.changed_data
+                }
+            )
+        return super().form_valid(form)
+
+    def get_success_url(self) -> str:
+        return reverse('control:event.orders.checkinlists.show', kwargs={
+            'organizer': self.request.event.organizer.slug,
+            'event': self.request.event.slug,
+            'list': self.object.pk
+        })
+
+    def form_invalid(self, form):
+        messages.error(self.request, _('We could not save your changes. See below for details.'))
+        return super().form_invalid(form)
+
+
+class CheckinListDelete(EventPermissionRequiredMixin, DeleteView):
+    model = CheckinList
+    template_name = 'pretixcontrol/checkin/list_delete.html'
+    permission = 'can_change_event_settings'
+    context_object_name = 'checkinlist'
+
+    def get_object(self, queryset=None) -> CheckinList:
+        try:
+            return self.request.event.checkin_lists.get(
+                id=self.kwargs['list']
+            )
+        except CheckinList.DoesNotExist:
+            raise Http404(_("The requested list does not exist."))
+
+    @transaction.atomic
+    def delete(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        success_url = self.get_success_url()
+        self.object.log_action(action='pretix.event.orders.deleted', user=request.user)
+        self.object.delete()
+        messages.success(self.request, _('The selected list has been deleted.'))
+        return HttpResponseRedirect(success_url)
+
+    def get_success_url(self) -> str:
+        return reverse('control:event.orders.checkinlists', kwargs={
+            'organizer': self.request.event.organizer.slug,
+            'event': self.request.event.slug,
+        })

src/pretix/control/views/dashboards.py

@@ -20,6 +20,7 @@ from pretix.base.models import (
     Event, Item, Order, OrderPosition, RequiredAction, SubEvent, Voucher,
     WaitingListEntry,
 )
+from pretix.base.models.checkin import CheckinList
 from pretix.control.forms.event import CommentForm
 from pretix.control.signals import (
     event_dashboard_widgets, user_dashboard_widgets,
@@ -190,7 +191,7 @@ def shop_state_widget(sender, **kwargs):
 
 
 @receiver(signal=event_dashboard_widgets)
-def checkin_widget(sender, **kwargs):
+def checkin_widget(sender, subevent=None, **kwargs):
     size_qs = OrderPosition.objects.filter(order__event=sender, order__status='p')
     checked_qs = OrderPosition.objects.filter(order__event=sender, order__status='p', checkins__isnull=False)
 
@@ -199,15 +200,22 @@ def checkin_widget(sender, **kwargs):
         size_qs = size_qs.filter(item__admission=True)
         checked_qs = checked_qs.filter(item__admission=True)
 
-    return [{
-        'content': NUM_WIDGET.format(num='{}/{}'.format(checked_qs.count(), size_qs.count()), text=_('Checked in')),
-        'display_size': 'small',
-        'priority': 50,
-        'url': reverse('control:event.orders.checkins', kwargs={
-            'event': sender.slug,
-            'organizer': sender.organizer.slug
+    widgets = []
+    qs = sender.checkin_lists.filter(subevent=subevent)
+    qs = CheckinList.annotate_with_numbers(qs, sender)
+    for cl in qs:
+        widgets.append({
+            'content': NUM_WIDGET.format(num='{}/{}'.format(cl.checkin_count, cl.position_count),
+                                         text=_('Checked in – {list}').format(list=escape(cl.name))),
+            'display_size': 'small',
+            'priority': 50,
+            'url': reverse('control:event.orders.checkinlists.show', kwargs={
+                'event': sender.slug,
+                'organizer': sender.organizer.slug,
+                'list': cl.pk
+            })
         })
-    }]
+    return widgets
 
 
 @receiver(signal=event_dashboard_widgets)

src/pretix/control/views/main.py

@@ -15,6 +15,7 @@ from django.views.generic import ListView
 from formtools.wizard.views import SessionWizardView
 from i18nfield.strings import LazyI18nString
 
+from pretix.base.i18n import language
 from pretix.base.models import Event, Organizer, Quota, Team
 from pretix.control.forms.event import (
     EventWizardBasicsForm, EventWizardCopyForm, EventWizardFoundationForm,
@@ -143,7 +144,7 @@ class EventWizard(SessionWizardView):
         basics_data = self.get_cleaned_data_for_step('basics')
         copy_data = self.get_cleaned_data_for_step('copy')
 
-        with transaction.atomic():
+        with transaction.atomic(), language(basics_data['locale']):
             event = form_dict['basics'].instance
             event.organizer = foundation_data['organizer']
             event.plugins = settings.PRETIX_PLUGINS_DEFAULT
@@ -165,7 +166,7 @@ class EventWizard(SessionWizardView):
                 t.limit_events.add(event)
 
             if event.has_subevents:
-                event.subevents.create(
+                se = event.subevents.create(
                     name=event.name,
                     date_from=event.date_from,
                     date_to=event.date_to,
@@ -191,6 +192,17 @@ class EventWizard(SessionWizardView):
             if copy_data and copy_data['copy_from_event']:
                 from_event = copy_data['copy_from_event']
                 event.copy_data_from(from_event)
+            elif event.has_subevents:
+                event.checkin_lists.create(
+                    name=str(se),
+                    all_products=True,
+                    subevent=se
+                )
+            else:
+                event.checkin_lists.create(
+                    name=_('Default'),
+                    all_products=True
+                )
 
             event.settings.set('timezone', basics_data['timezone'])
             event.settings.set('locale', basics_data['locale'])

src/pretix/control/views/orders.py

@@ -147,7 +147,7 @@ class OrderDetail(OrderView):
         ).select_related(
             'item', 'variation', 'addon_to', 'tax_rule'
         ).prefetch_related(
-            'item__questions', 'answers', 'answers__question', 'checkins'
+            'item__questions', 'answers', 'answers__question', 'checkins', 'checkins__list'
         ).order_by('positionid')
 
         positions = []
@@ -906,9 +906,21 @@ class ExportMixin:
         responses = register_data_exporters.send(self.request.event)
         for receiver, response in responses:
             ex = response(self.request.event)
+            if self.request.GET.get("identifier") and ex.identifier != self.request.GET.get("identifier"):
+                continue
+
+            # Use form parse cycle to generate useful defaults
+            test_form = ExporterForm(data=self.request.GET, prefix=ex.identifier)
+            test_form.fields = ex.export_form_fields
+            test_form.is_valid()
+            initial = {
+                k: v for k, v in test_form.cleaned_data.items() if ex.identifier + "-" + k in self.request.GET
+            }
+
             ex.form = ExporterForm(
                 data=(self.request.POST if self.request.method == 'POST' else None),
-                prefix=ex.identifier
+                prefix=ex.identifier,
+                initial=initial
             )
             ex.form.fields = ex.export_form_fields
             exporters.append(ex)

src/pretix/control/views/subevents.py

@@ -11,13 +11,15 @@ from django.utils.functional import cached_property
 from django.utils.translation import pgettext_lazy, ugettext_lazy as _
 from django.views.generic import CreateView, DeleteView, ListView, UpdateView
 
+from pretix.base.models.checkin import CheckinList
 from pretix.base.models.event import SubEvent, SubEventMetaValue
 from pretix.base.models.items import Quota, SubEventItem, SubEventItemVariation
+from pretix.control.forms.checkin import CheckinListForm
 from pretix.control.forms.filter import SubEventFilterForm
 from pretix.control.forms.item import QuotaForm
 from pretix.control.forms.subevents import (
-    QuotaFormSet, SubEventForm, SubEventItemForm, SubEventItemVariationForm,
-    SubEventMetaValueForm,
+    CheckinListFormSet, QuotaFormSet, SubEventForm, SubEventItemForm,
+    SubEventItemVariationForm, SubEventMetaValueForm,
 )
 from pretix.control.permissions import EventPermissionRequiredMixin
 from pretix.control.views.event import MetaDataEditorMixin
@@ -132,6 +134,41 @@ class SubEventEditorMixin(MetaDataEditorMixin):
             data=(self.request.POST if self.request.method == "POST" else None)
         )
 
+    @cached_property
+    def cl_formset(self):
+        extra = 0
+        kwargs = {}
+
+        if self.copy_from:
+            kwargs['initial'] = [
+                {
+                    'name': cl.name,
+                    'all_products': cl.all_products,
+                    'limit_products': cl.limit_products.all(),
+                } for cl in self.copy_from.checkinlist_set.prefetch_related('limit_products')
+            ]
+            extra = len(kwargs['initial'])
+        elif not self.object:
+            kwargs['initial'] = [
+                {
+                    'name': '',
+                    'all_products': True,
+                }
+            ]
+            extra = 1
+
+        formsetclass = inlineformset_factory(
+            SubEvent, CheckinList,
+            form=CheckinListForm, formset=CheckinListFormSet,
+            can_order=False, can_delete=True, extra=extra,
+        )
+        if self.object:
+            kwargs['queryset'] = self.object.checkinlist_set.prefetch_related('limit_products')
+
+        return formsetclass(self.request.POST if self.request.method == "POST" else None,
+                            instance=self.object,
+                            event=self.request.event, **kwargs)
+
     @cached_property
     def formset(self):
         extra = 0
@@ -161,6 +198,38 @@ class SubEventEditorMixin(MetaDataEditorMixin):
                             instance=self.object,
                             event=self.request.event, **kwargs)
 
+    def save_cl_formset(self, obj):
+        for form in self.cl_formset.initial_forms:
+            if form in self.cl_formset.deleted_forms:
+                if not form.instance.pk:
+                    continue
+                form.instance.log_action(action='pretix.event.checkinlist.deleted', user=self.request.user)
+                form.instance.delete()
+                form.instance.pk = None
+            elif form.has_changed():
+                form.instance.subevent = obj
+                form.instance.event = obj.event
+                form.save()
+                change_data = {k: form.cleaned_data.get(k) for k in form.changed_data}
+                change_data['id'] = form.instance.pk
+                form.instance.log_action(
+                    'pretix.event.checkinlist.changed', user=self.request.user, data={
+                        k: form.cleaned_data.get(k) for k in form.changed_data
+                    }
+                )
+
+        for form in self.cl_formset.extra_forms:
+            if not form.has_changed():
+                continue
+            if self.formset._should_delete_form(form):
+                continue
+            form.instance.subevent = obj
+            form.instance.event = obj.event
+            form.save()
+            change_data = {k: form.cleaned_data.get(k) for k in form.changed_data}
+            change_data['id'] = form.instance.pk
+            form.instance.log_action(action='pretix.event.checkinlist.added', user=self.request.user, data=change_data)
+
     def save_formset(self, obj):
         for form in self.formset.initial_forms:
             if form in self.formset.deleted_forms:
@@ -204,6 +273,7 @@ class SubEventEditorMixin(MetaDataEditorMixin):
     def get_context_data(self, **kwargs):
         ctx = super().get_context_data(**kwargs)
         ctx['formset'] = self.formset
+        ctx['cl_formset'] = self.cl_formset
         ctx['itemvar_forms'] = self.itemvar_forms
         ctx['meta_forms'] = self.meta_forms
         return ctx
@@ -259,7 +329,7 @@ class SubEventEditorMixin(MetaDataEditorMixin):
     def is_valid(self, form):
         return form.is_valid() and all([f.is_valid() for f in self.itemvar_forms]) and self.formset.is_valid() and (
             all([f.is_valid() for f in self.meta_forms])
-        )
+        ) and self.cl_formset.is_valid()
 
 
 class SubEventUpdate(EventPermissionRequiredMixin, SubEventEditorMixin, UpdateView):
@@ -288,6 +358,7 @@ class SubEventUpdate(EventPermissionRequiredMixin, SubEventEditorMixin, UpdateVi
     @transaction.atomic
     def form_valid(self, form):
         self.save_formset(self.object)
+        self.save_cl_formset(self.object)
         self.save_meta()
 
         for f in self.itemvar_forms:
@@ -355,6 +426,7 @@ class SubEventCreate(SubEventEditorMixin, EventPermissionRequiredMixin, CreateVi
         form.instance.log_action('pretix.subevent.added', data=dict(form.cleaned_data), user=self.request.user)
 
         self.save_formset(form.instance)
+        self.save_cl_formset(form.instance)
         for f in self.itemvar_forms:
             f.instance.subevent = form.instance
             f.save()