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)
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())
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])
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())
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)
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())
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())
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, }, )
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)
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])
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)
def post(self, request, *args, **kwargs): cancel_order(self.order) return redirect(self.get_order_url())