Reduce functional complexity (McCabe max 18 → max 12)

src/pretix/presale/views/__init__.py

@@ -52,10 +52,9 @@ class CartDisplayMixin:
         ))
 
     def get_cart(self, answers=False, queryset=None, payment_fee=None):
-        if queryset is None:
-            queryset = CartPosition.objects.current.filter(
-                Q(user=self.request.user) & Q(event=self.request.event)
-            )
+        queryset = queryset or CartPosition.objects.current.filter(
+            Q(user=self.request.user) & Q(event=self.request.event)
+        )
 
         prefetch = ['variation__values', 'variation__values__prop']
         if answers:
@@ -87,33 +86,18 @@ class CartDisplayMixin:
             group.total = group.count * group.price
             group.has_questions = answers and k[0] != ""
             if answers:
-                group.answ = {}
-                for a in group.answers.all():
-                    group.answ[a.question_id] = a.answer
-                group.questions = []
-                for q in group.item.questions.all():
-                    if q.identity in group.answ:
-                        q.answer = group.answ[q.identity]
-                    else:
-                        q.answer = ""
-                    group.questions.append(q)
+                group.cache_answers()
             positions.append(group)
 
         total = sum(p.total for p in positions)
 
-        if payment_fee is None:
-            payment_fee = 0
-            if 'payment' in self.request.session:
-                responses = register_payment_providers.send(self.request.event)
-                for receiver, response in responses:
-                    provider = response(self.request.event)
-                    if provider.identifier == self.request.session['payment']:
-                        payment_fee = provider.calculate_fee(total)
+        payment_fee = payment_fee or self.get_payment_fee(total)
 
         try:
             minutes_left = max(min(p.expires for p in positions) - now(), timedelta()).seconds // 60 if positions else 0
         except AttributeError:
             minutes_left = None
+
         return {
             'positions': positions,
             'raw': cartpos,
@@ -123,6 +107,16 @@ class CartDisplayMixin:
             'minutes_left': minutes_left,
         }
 
+    def get_payment_fee(self, total):
+        payment_fee = 0
+        if 'payment' in self.request.session:
+            responses = register_payment_providers.send(self.request.event)
+            for receiver, response in responses:
+                provider = response(self.request.event)
+                if provider.identifier == self.request.session['payment']:
+                    payment_fee = provider.calculate_fee(total)
+        return payment_fee
+
 
 class EventViewMixin:
 

src/pretix/presale/views/cart.py

@@ -59,14 +59,6 @@ class CartActionMixin:
             return []
         return items
 
-    def _re_add_position(self, items, position):
-        for i, tup in enumerate(items):
-            if tup[0] == position.item_id and tup[1] == position.variation_id:
-                items[i] = (tup[0], tup[1], tup[2] + 1)
-                return items
-        items.append((position.item_id, position.variation_id, 1))
-        return items
-
 
 class CartRemove(EventViewMixin, CartActionMixin, EventLoginRequiredMixin, View):
 
@@ -107,27 +99,43 @@ class CartAdd(EventViewMixin, CartActionMixin, View):
         self.msg_some_unavailable = False
 
     def post(self, request, *args, **kwargs):
-        items = self._items_from_post_data()
+        self.items = self._items_from_post_data()
 
         # We do not use EventLoginRequiredMixin here, as we want to store stuff into the
         # session beforehand
         if not request.user.is_authenticated() or \
                 (request.user.event is not None and request.user.event != request.event):
-            request.session['cart_tmp'] = json.dumps(items)
+            request.session['cart_tmp'] = json.dumps(self.items)
             return redirect_to_login(
                 self.get_success_url(), reverse('presale:event.checkout.login', kwargs={
                     'organizer': request.event.organizer.slug,
                     'event': request.event.slug,
                 }), 'next'
             )
-        return self.process(items)
+        return self.process()
 
     def error_message(self, msg, important=False):
         if not self.msg_some_unavailable or important:
             self.msg_some_unavailable = True
             messages.error(self.request, msg)
 
-    def process(self, items):
+    def _re_add_position(self, position):
+        for i, tup in enumerate(self.items):
+            if tup[0] == position.item_id and tup[1] == position.variation_id:
+                self.items[i] = (tup[0], tup[1], tup[2] + 1)
+                return self.items
+        self.items.append((position.item_id, position.variation_id, 1))
+
+    def _expired_positions(self):
+        # For items that are already expired, we have to delete and re-add them, as they might
+        # be no longer available or prices might have changed. Sorry!
+        for cp in CartPosition.objects.current.filter(
+            Q(user=self.request.user) & Q(event=self.request.event) & Q(expires__lte=now())
+        ):
+            self._re_add_position(cp)
+            cp.delete()
+
+    def process(self):
         # Extend this user's cart session to 30 minutes from now to ensure all items in the
         # cart expire at the same time
         # We can extend the reservation of items which are not yet expired without risk
@@ -135,18 +143,13 @@ class CartAdd(EventViewMixin, CartActionMixin, View):
             Q(user=self.request.user) & Q(event=self.request.event) & Q(expires__gt=now())
         ).update(expires=now() + timedelta(minutes=30))
 
-        # For items that are already expired, we have to delete and re-add them, as they might
-        # be no longer available or prices might have changed. Sorry!
-        for cp in CartPosition.objects.current.filter(
-                Q(user=self.request.user) & Q(event=self.request.event) & Q(expires__lte=now())):
-            items = self._re_add_position(items, cp)
-            cp.delete()
+        self._expired_positions()
 
-        if not items:
+        if not self.items:
             return redirect(self.get_failure_url())
 
         existing = CartPosition.objects.current.filter(user=self.request.user, event=self.request.event).count()
-        if sum(i[2] for i in items) + existing > int(self.request.event.settings.max_items_per_order):
+        if sum(i[2] for i in self.items) + existing > int(self.request.event.settings.max_items_per_order):
             # TODO: i18n plurals
             self.error_message(self.error_messages['max_items'] % self.request.event.settings.max_items_per_order)
             return redirect(self.get_failure_url())
@@ -156,19 +159,19 @@ class CartAdd(EventViewMixin, CartActionMixin, View):
             i.identity: i for i
             in Item.objects.current.filter(
                 event=self.request.event,
-                identity__in=[i[0] for i in items]
+                identity__in=[i[0] for i in self.items]
             ).prefetch_related("quotas")
         }
         variations_cache = {
             v.identity: v for v
             in ItemVariation.objects.current.filter(
                 item__event=self.request.event,
-                identity__in=[i[1] for i in items if i[1] is not None]
+                identity__in=[i[1] for i in self.items if i[1] is not None]
             ).select_related("item", "item__event").prefetch_related("quotas", "values", "values__prop")
         }
 
         # Process the request itself
-        for i in items:
+        for i in self.items:
             # Check whether the specified items are part of what we just fetched from the database
             # If they are not, the user supplied item IDs which either do not exist or belong to
             # a different event
@@ -183,13 +186,11 @@ class CartAdd(EventViewMixin, CartActionMixin, View):
             # (b) make the item/variation unavailable. If neither is the case, check_restriction
             # will correctly return the default price
             price = item.check_restrictions() if variation is None else variation.check_restrictions()
-            if price is False:
-                self.error_message(self.error_messages['unavailable'])
-                continue
 
             # Fetch all quotas. If there are no quotas, this item is not allowed to be sold.
             quotas = list(item.quotas.all()) if variation is None else list(variation.quotas.all())
-            if len(quotas) == 0:
+
+            if price is False or len(quotas) == 0:
                 self.error_message(self.error_messages['unavailable'])
                 continue
 
@@ -201,15 +202,14 @@ class CartAdd(EventViewMixin, CartActionMixin, View):
                     # quota while we're doing so.
                     quota.lock()
                     avail = quota.availability()
-                    if avail[0] != Quota.AVAILABILITY_OK:
-                        # This quota is sold out/currently unavailable, so do not sell this at all
-                        self.error_message(self.error_messages['unavailable'])
-                        quota_ok = 0
-                        break
-                    elif avail[1] < i[2]:
-                        # This quota is available, but with less than i[2] items left, so we have to
+                    if avail[1] < i[2]:
+                        # This quota is not available or less than i[2] items are left, so we have to
                         # reduce the number of bought items
-                        self.error_message(self.error_messages['in_part'])
+                        self.error_message(
+                            self.error_messages['unavailable']
+                            if avail[0] != Quota.AVAILABILITY_OK
+                            else self.error_messages['in_part']
+                        )
                         quota_ok = min(quota_ok, avail[1])
 
                 # Create a CartPosition for as much items as we can

src/pretix/presale/views/checkout.py

@@ -284,10 +284,7 @@ class OrderConfirm(EventViewMixin, CartDisplayMixin, EventLoginRequiredMixin, Ch
 
     def get(self, request, *args, **kwargs):
         self.request = request
-        check = self.check_process(request)
-        if check:
-            return check
-        return super().get(request, *args, **kwargs)
+        return self.check_process(request) or super().get(request, *args, **kwargs)
 
     def error_message(self, msg, important=False):
         if not self.msg_some_unavailable or important:
@@ -296,10 +293,9 @@ class OrderConfirm(EventViewMixin, CartDisplayMixin, EventLoginRequiredMixin, Ch
 
     def post(self, request, *args, **kwargs):
         self.request = request
-        check = self.check_process(request)
-        if check:
-            return
+        return self.check_process(request) or self.perform_order(request)
 
+    def perform_order(self, request):
         dt = now()
         quotas_locked = set()
 
@@ -309,10 +305,7 @@ class OrderConfirm(EventViewMixin, CartDisplayMixin, EventLoginRequiredMixin, Ch
                 quotas = list(cp.item.quotas.all()) if cp.variation is None else list(cp.variation.quotas.all())
                 if cp.expires < dt:
                     price = cp.item.check_restrictions() if cp.variation is None else cp.variation.check_restrictions()
-                    if price is False:
-                        self.error_message(self.error_messages['unavailable'])
-                        continue
-                    if len(quotas) == 0:
+                    if price is False or len(quotas) == 0:
                         self.error_message(self.error_messages['unavailable'])
                         continue
                     if price != cp.price:
@@ -341,40 +334,10 @@ class OrderConfirm(EventViewMixin, CartDisplayMixin, EventLoginRequiredMixin, Ch
                         cp.expires = now() + timedelta(minutes=self.request.event.settings.get('reservation_time', as_type=int))
                         cp.save()
             if not self.msg_some_unavailable:  # Everything went well
-                with transaction.atomic():
-                    total = sum([c.price for c in cartpos])
-                    payment_fee = self.payment_provider.calculate_fee(total)
-                    total += payment_fee
-                    expires = [dt + timedelta(days=request.event.payment_term_days)]
-                    if request.event.payment_term_last:
-                        expires.append(request.event.payment_term_last)
-                    order = Order.objects.create(
-                        status=Order.STATUS_PENDING,
-                        event=request.event,
-                        user=request.user,
-                        datetime=dt,
-                        expires=min(expires),
-                        total=total,
-                        payment_fee=payment_fee,
-                        payment_provider=self.payment_provider.identifier,
-                    )
-                    for cp in cartpos:
-                        op = OrderPosition.objects.create(
-                            order=order, item=cp.item, variation=cp.variation,
-                            price=cp.price, attendee_name=cp.attendee_name
-                        )
-                        for answ in cp.answers.all():
-                            answ = answ.clone()
-                            answ.orderposition = op
-                            answ.cartposition = None
-                            answ.save()
-                        cp.delete()
-                    messages.success(request, _('Your order has been placed.'))
+                order = self._place_order(cartpos, dt)
+                messages.success(request, _('Your order has been placed.'))
                 resp = self.payment_provider.checkout_perform(request, order)
-                if isinstance(resp, str):
-                    return redirect(str)
-                else:
-                    return redirect(self.get_order_url(order))
+                return redirect(resp or self.get_order_url(order))
 
         except Quota.LockTimeoutException:
             # Is raised when there are too many threads asking for quota locks and we were
@@ -386,3 +349,24 @@ class OrderConfirm(EventViewMixin, CartDisplayMixin, EventLoginRequiredMixin, Ch
                 quota.release()
 
         return redirect(self.get_confirm_url())
+
+    @transaction.atomic()
+    def _place_order(self, cartpos, dt):
+        total = sum([c.price for c in cartpos])
+        payment_fee = self.payment_provider.calculate_fee(total)
+        total += payment_fee
+        expires = [dt + timedelta(days=self.request.event.payment_term_days)]
+        if self.request.event.payment_term_last:
+            expires.append(self.request.event.payment_term_last)
+        order = Order.objects.create(
+            status=Order.STATUS_PENDING,
+            event=self.request.event,
+            user=self.request.user,
+            datetime=dt,
+            expires=min(expires),
+            total=total,
+            payment_fee=payment_fee,
+            payment_provider=self.payment_provider.identifier,
+        )
+        OrderPosition.transform_cart_positions(cartpos, order)
+        return order