Beispiel #1
0
    def mark_canceled(self, request, **kwargs):
        send_mail = request.data.get('send_email', True)
        cancellation_fee = request.data.get('cancellation_fee', None)
        if cancellation_fee:
            try:
                cancellation_fee = float(Decimal(cancellation_fee))
            except:
                cancellation_fee = None

        order = self.get_object()
        if not order.cancel_allowed():
            return Response(
                {'detail': 'The order is not allowed to be canceled.'},
                status=status.HTTP_400_BAD_REQUEST)

        try:
            cancel_order(
                order,
                user=request.user if request.user.is_authenticated else None,
                api_token=request.auth
                if isinstance(request.auth, TeamAPIToken) else None,
                device=request.auth
                if isinstance(request.auth, Device) else None,
                oauth_application=request.auth.application if isinstance(
                    request.auth, OAuthAccessToken) else None,
                send_mail=send_mail,
                cancellation_fee=cancellation_fee)
        except OrderError as e:
            return Response({'detail': str(e)},
                            status=status.HTTP_400_BAD_REQUEST)
        return self.retrieve(request, [], **kwargs)
Beispiel #2
0
 def post(self, *args, **kwargs):
     to = self.request.POST.get('status', '')
     if self.order.status in (Order.STATUS_PENDING, Order.STATUS_EXPIRED) and to == 'p':
         try:
             mark_order_paid(self.order, manual=True, user=self.request.user)
         except Quota.QuotaExceededException as e:
             messages.error(self.request, str(e))
         else:
             messages.success(self.request, _('The order has been marked as paid.'))
     elif self.order.status == Order.STATUS_PENDING and to == 'c':
         cancel_order(self.order, user=self.request.user)
         messages.success(self.request, _('The order has been cancelled.'))
     elif self.order.status == Order.STATUS_PAID and to == 'n':
         self.order.status = Order.STATUS_PENDING
         self.order.payment_manual = True
         self.order.save()
         self.order.log_action('pretix.event.order.unpaid', user=self.request.user)
         messages.success(self.request, _('The order has been marked as not paid.'))
     elif self.order.status == Order.STATUS_PENDING and to == 'e':
         self.order.status = Order.STATUS_EXPIRED
         self.order.save()
         self.order.log_action('pretix.event.order.expired', user=self.request.user)
         messages.success(self.request, _('The order has been marked as expired.'))
     elif self.order.status == Order.STATUS_PAID and to == 'r':
         ret = self.payment_provider.order_control_refund_perform(self.request, self.order)
         if ret:
             return redirect(ret)
     return redirect(self.get_order_url())
Beispiel #3
0
    def test_voucher_reuse(self):
        self.quota.items.add(self.item1)
        v = Voucher.objects.create(quota=self.quota, event=self.event, valid_until=now() + timedelta(days=5))
        self.assertTrue(v.is_active())
        self.assertFalse(v.is_in_cart())
        self.assertFalse(v.is_ordered())

        # use a voucher normally
        cart = CartPosition.objects.create(event=self.event, item=self.item1, price=self.item1.default_price,
                                           expires=now() + timedelta(days=3), voucher=v)
        self.assertTrue(v.is_active())
        self.assertTrue(v.is_in_cart())
        self.assertFalse(v.is_ordered())

        order = perform_order(event=self.event.id, payment_provider='free', positions=[cart.id])
        v.refresh_from_db()
        self.assertFalse(v.is_active())
        self.assertFalse(v.is_in_cart())
        self.assertTrue(v.is_ordered())

        # assert that the voucher cannot be reused
        cart = CartPosition.objects.create(event=self.event, item=self.item1, price=self.item1.default_price,
                                           expires=now() + timedelta(days=3), voucher=v)
        self.assertRaises(OrderError, perform_order, event=self.event.id, payment_provider='free', positions=[cart.id])

        # assert that the voucher can be re-used after cancelling the successful order
        cancel_order(order)
        v.refresh_from_db()
        self.assertTrue(v.is_active())
        self.assertFalse(v.is_in_cart())
        self.assertTrue(v.is_ordered())

        cart = CartPosition.objects.create(event=self.event, item=self.item1, price=self.item1.default_price,
                                           expires=now() + timedelta(days=3), voucher=v)
        perform_order(event=self.event.id, payment_provider='free', positions=[cart.id])
Beispiel #4
0
 def post(self, *args, **kwargs):
     to = self.request.POST.get('status', '')
     if self.order.status in (Order.STATUS_PENDING, Order.STATUS_EXPIRED) and to == 'p':
         try:
             mark_order_paid(self.order, manual=True, user=self.request.user)
         except Quota.QuotaExceededException as e:
             messages.error(self.request, str(e))
         except SendMailException:
             messages.warning(self.request, _('The order has been marked as paid, but we were unable to send a confirmation mail.'))
         else:
             messages.success(self.request, _('The order has been marked as paid.'))
     elif self.order.status == Order.STATUS_PENDING and to == 'c':
         cancel_order(self.order, user=self.request.user, send_mail=self.request.POST.get("send_email") == "on")
         messages.success(self.request, _('The order has been canceled.'))
     elif self.order.status == Order.STATUS_PAID and to == 'n':
         self.order.status = Order.STATUS_PENDING
         self.order.payment_manual = True
         self.order.save()
         self.order.log_action('pretix.event.order.unpaid', user=self.request.user)
         messages.success(self.request, _('The order has been marked as not paid.'))
     elif self.order.status == Order.STATUS_PENDING and to == 'e':
         self.order.status = Order.STATUS_EXPIRED
         self.order.save()
         self.order.log_action('pretix.event.order.expired', user=self.request.user)
         messages.success(self.request, _('The order has been marked as expired.'))
     elif self.order.status == Order.STATUS_PAID and to == 'r':
         ret = self.payment_provider.order_control_refund_perform(self.request, self.order)
         if ret:
             return redirect(ret)
     return redirect(self.get_order_url())
Beispiel #5
0
    def mark_canceled(self, request, **kwargs):
        send_mail = request.data.get('send_email', True)
        cancellation_fee = request.data.get('cancellation_fee', None)
        if cancellation_fee:
            try:
                cancellation_fee = float(Decimal(cancellation_fee))
            except:
                cancellation_fee = None

        order = self.get_object()
        if not order.cancel_allowed():
            return Response(
                {'detail': 'The order is not allowed to be canceled.'},
                status=status.HTTP_400_BAD_REQUEST
            )

        try:
            cancel_order(
                order,
                user=request.user if request.user.is_authenticated else None,
                api_token=request.auth if isinstance(request.auth, TeamAPIToken) else None,
                device=request.auth if isinstance(request.auth, Device) else None,
                oauth_application=request.auth.application if isinstance(request.auth, OAuthAccessToken) else None,
                send_mail=send_mail,
                cancellation_fee=cancellation_fee
            )
        except OrderError as e:
            return Response(
                {'detail': str(e)},
                status=status.HTTP_400_BAD_REQUEST
            )
        return self.retrieve(request, [], **kwargs)
Beispiel #6
0
 def post(self, *args, **kwargs):
     to = self.request.POST.get('status', '')
     if self.order.status == 'n' and to == 'p':
         try:
             mark_order_paid(self.order,
                             manual=True,
                             user=self.request.user)
         except Quota.QuotaExceededException as e:
             messages.error(self.request, str(e))
         else:
             messages.success(self.request,
                              _('The order has been marked as paid.'))
     elif self.order.status == 'n' and to == 'c':
         cancel_order(self.order, user=self.request.user)
         messages.success(self.request, _('The order has been cancelled.'))
     elif self.order.status == 'p' and to == 'n':
         self.order.status = Order.STATUS_PENDING
         self.order.payment_manual = True
         self.order.save()
         self.order.log_action('pretix.event.order.unpaid',
                               user=self.request.user)
         messages.success(self.request,
                          _('The order has been marked as not paid.'))
     elif self.order.status == 'p' and to == 'r':
         ret = self.payment_provider.order_control_refund_perform(
             self.request, self.order)
         if ret:
             return redirect(ret)
     return redirect(self.get_order_url())
Beispiel #7
0
 def post(self, *args, **kwargs):
     to = self.request.POST.get('status', '')
     if self.order.status in (Order.STATUS_PENDING,
                              Order.STATUS_EXPIRED) and to == 'p':
         if not self.mark_paid_form.is_valid():
             return render(self.request, 'pretixcontrol/order/pay.html', {
                 'form': self.mark_paid_form,
                 'order': self.order,
             })
         try:
             mark_order_paid(self.order,
                             manual=True,
                             user=self.request.user,
                             count_waitinglist=False,
                             force=self.mark_paid_form.cleaned_data.get(
                                 'force', False))
         except Quota.QuotaExceededException as e:
             messages.error(self.request, str(e))
         except SendMailException:
             messages.warning(
                 self.request,
                 _('The order has been marked as paid, but we were unable to send a confirmation mail.'
                   ))
         else:
             messages.success(self.request,
                              _('The order has been marked as paid.'))
     elif self.order.cancel_allowed() and to == 'c':
         cancel_order(self.order,
                      user=self.request.user,
                      send_mail=self.request.POST.get("send_email") == "on")
         messages.success(self.request, _('The order has been canceled.'))
     elif self.order.status == Order.STATUS_PAID and to == 'n':
         self.order.status = Order.STATUS_PENDING
         self.order.payment_manual = True
         self.order.save()
         self.order.log_action('pretix.event.order.unpaid',
                               user=self.request.user)
         messages.success(self.request,
                          _('The order has been marked as not paid.'))
     elif self.order.status == Order.STATUS_PENDING and to == 'e':
         mark_order_expired(self.order, user=self.request.user)
         messages.success(self.request,
                          _('The order has been marked as expired.'))
     elif self.order.status == Order.STATUS_PAID and to == 'r':
         if not self.payment_provider:
             messages.error(
                 self.request,
                 _('This order is not assigned to a known payment provider.'
                   ))
         else:
             ret = self.payment_provider.order_control_refund_perform(
                 self.request, self.order)
             if ret:
                 return redirect(ret)
     return redirect(self.get_order_url())
Beispiel #8
0
    def cancel_for(self, other):
        """Called when an order is marked as paid.

        Makes sure that item, variation and subevent match before
        calling this method.
        """

        if not self.event.settings.cancel_orderpositions:
            raise Exception(
                "Order position canceling is currently not allowed")

        if (self.position.subevent != other.subevent
                or self.position.item != other.item
                or self.position.variation != other.variation):
            raise Exception("Cancelation failed, orders are not equal")
        if not can_be_canceled(self.event, self.position.item,
                               self.position.subevent):
            raise Exception("Cancelation failed, currently not allowed")

        # Make sure AGAIN that the state is alright, because timings
        self.refresh_from_db()
        if not self.state == self.States.REQUESTED:
            raise Exception("Not in 'requesting' state.")
        if self.position.price > other.price:
            raise Exception("Cannot cancel for a cheaper product.")

        try:
            change_manager = OrderChangeManager(order=self.position.order)
            change_manager.cancel(position=self.position)
            change_manager.commit()
        except OrderError:  # Let's hope this order error is because we're trying to empty the order
            cancel_order(
                self.position.order.pk,
                cancellation_fee=self.event.settings.swap_cancellation_fee,
                try_auto_refund=True,
            )
        self.state = self.States.COMPLETED
        self.target_order = other.order  # Should be set already, let's just make sure
        self.save()
        self.position.order.log_action(
            "pretix_swap.cancelation.complete",
            data={
                "position": self.position.pk,
                "positionid": self.position.positionid,
                "other_position": other.pk,
                "other_positionid": other.positionid,
                "other_order": other.order.code,
            },
        )
Beispiel #9
0
    def mark_canceled(self, request, **kwargs):
        send_mail = request.data.get('send_email', True)

        order = self.get_object()
        if not order.cancel_allowed():
            return Response(
                {'detail': 'The order is not allowed to be canceled.'},
                status=status.HTTP_400_BAD_REQUEST)

        cancel_order(
            order,
            user=request.user if request.user.is_authenticated else None,
            api_token=(request.auth
                       if isinstance(request.auth, TeamAPIToken) else None),
            send_mail=send_mail)
        return self.retrieve(request, [], **kwargs)
Beispiel #10
0
    def test_voucher_reuse(self):
        self.quota.items.add(self.item1)
        v = Voucher.objects.create(quota=self.quota, event=self.event, valid_until=now() + timedelta(days=5))

        # use a voucher normally
        cart = CartPosition.objects.create(event=self.event, item=self.item1, price=self.item1.default_price,
                                           expires=now() + timedelta(days=3), voucher=v)
        order = perform_order(event=self.event.id, payment_provider='free', positions=[cart.id])

        # assert that the voucher cannot be reused
        cart = CartPosition.objects.create(event=self.event, item=self.item1, price=self.item1.default_price,
                                           expires=now() + timedelta(days=3), voucher=v)
        self.assertRaises(OrderError, perform_order, event=self.event.id, payment_provider='free', positions=[cart.id])

        # assert that the voucher can be re-used after cancelling the successful order
        cancel_order(order)
        cart = CartPosition.objects.create(event=self.event, item=self.item1, price=self.item1.default_price,
                                           expires=now() + timedelta(days=3), voucher=v)
        perform_order(event=self.event.id, payment_provider='free', positions=[cart.id])
Beispiel #11
0
    def mark_canceled(self, request, **kwargs):
        send_mail = request.data.get('send_email', True)

        order = self.get_object()
        if not order.cancel_allowed():
            return Response(
                {'detail': 'The order is not allowed to be canceled.'},
                status=status.HTTP_400_BAD_REQUEST
            )

        cancel_order(
            order,
            user=request.user if request.user.is_authenticated else None,
            api_token=request.auth if isinstance(request.auth, TeamAPIToken) else None,
            device=request.auth if isinstance(request.auth, Device) else None,
            oauth_application=request.auth.application if isinstance(request.auth, OAuthAccessToken) else None,
            send_mail=send_mail
        )
        return self.retrieve(request, [], **kwargs)
Beispiel #12
0
 def post(self, request, *args, **kwargs):
     cancel_order(self.order)
     return redirect(self.get_order_url())
Beispiel #13
0
 def post(self, request, *args, **kwargs):
     cancel_order(self.order)
     return redirect(self.get_order_url())