Self-service refund form (#1135)

* Auto-refund

* Add missing template

* Notification for requested refund

* Model-level tests

* Add front-end tests

* Default to notify

src/tests/base/test_models.py

@@ -16,8 +16,8 @@ from django.utils.timezone import now
 from pretix.base.i18n import language
 from pretix.base.models import (
     CachedFile, CartPosition, CheckinList, Event, Item, ItemCategory,
-    ItemVariation, Order, OrderPayment, OrderPosition, OrderRefund, Organizer,
-    Question, Quota, User, Voucher, WaitingListEntry,
+    ItemVariation, Order, OrderFee, OrderPayment, OrderPosition, OrderRefund,
+    Organizer, Question, Quota, User, Voucher, WaitingListEntry,
 )
 from pretix.base.models.event import SubEvent
 from pretix.base.models.items import SubEventItem, SubEventItemVariation
@@ -45,7 +45,7 @@ class BaseQuotaTestCase(TestCase):
         o = Organizer.objects.create(name='Dummy', slug='dummy')
         self.event = Event.objects.create(
             organizer=o, name='Dummy', slug='dummy',
-            date_from=now(),
+            date_from=now(), plugins='tests.testdummy'
         )
         self.quota = Quota.objects.create(name="Test", size=2, event=self.event)
         self.item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
@@ -600,7 +600,7 @@ class OrderTestCase(BaseQuotaTestCase):
         self.order = Order.objects.create(
             status=Order.STATUS_PENDING, event=self.event,
             datetime=now() - timedelta(days=5),
-            expires=now() + timedelta(days=5), total=46
+            expires=now() + timedelta(days=5), total=46,
         )
         self.quota.items.add(self.item1)
         self.op1 = OrderPosition.objects.create(order=self.order, item=self.item1,
@@ -845,7 +845,25 @@ class OrderTestCase(BaseQuotaTestCase):
                                     admission=True, allow_cancel=True)
         OrderPosition.objects.create(order=self.order, item=item1,
                                      variation=None, price=23)
-        assert self.order.can_user_cancel
+        assert self.order.user_cancel_allowed
+        self.event.settings.cancel_allow_user = False
+        assert not self.order.user_cancel_allowed
+
+    def test_can_cancel_order_free(self):
+        self.order.status = Order.STATUS_PAID
+        self.order.total = Decimal('0.00')
+        self.order.save()
+        assert self.order.user_cancel_allowed
+        self.event.settings.cancel_allow_user = False
+        assert not self.order.user_cancel_allowed
+
+    def test_can_cancel_order_paid(self):
+        self.order.status = Order.STATUS_PAID
+        self.order.save()
+        assert not self.order.user_cancel_allowed
+        self.event.settings.cancel_allow_user = False
+        self.event.settings.cancel_allow_user_paid = True
+        assert self.order.user_cancel_allowed
 
     def test_can_cancel_order_multiple(self):
         item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
@@ -856,14 +874,14 @@ class OrderTestCase(BaseQuotaTestCase):
                                      variation=None, price=23)
         OrderPosition.objects.create(order=self.order, item=item2,
                                      variation=None, price=23)
-        assert self.order.can_user_cancel
+        assert self.order.user_cancel_allowed
 
     def test_can_not_cancel_order(self):
         item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
                                     admission=True, allow_cancel=False)
         OrderPosition.objects.create(order=self.order, item=item1,
                                      variation=None, price=23)
-        assert self.order.can_user_cancel is False
+        assert self.order.user_cancel_allowed is False
 
     def test_can_not_cancel_order_multiple(self):
         item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
@@ -874,7 +892,7 @@ class OrderTestCase(BaseQuotaTestCase):
                                      variation=None, price=23)
         OrderPosition.objects.create(order=self.order, item=item2,
                                      variation=None, price=23)
-        assert self.order.can_user_cancel is False
+        assert self.order.user_cancel_allowed is False
 
     def test_can_not_cancel_order_multiple_mixed(self):
         item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
@@ -885,7 +903,7 @@ class OrderTestCase(BaseQuotaTestCase):
                                      variation=None, price=23)
         OrderPosition.objects.create(order=self.order, item=item2,
                                      variation=None, price=23)
-        assert self.order.can_user_cancel is False
+        assert self.order.user_cancel_allowed is False
 
     def test_no_duplicate_position_secret(self):
         item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
@@ -895,7 +913,119 @@ class OrderTestCase(BaseQuotaTestCase):
         p2 = OrderPosition.objects.create(order=self.order, item=item1, secret='ABC',
                                           variation=None, price=23)
         assert p1.secret != p2.secret
-        assert self.order.can_user_cancel is False
+        assert self.order.user_cancel_allowed is False
+
+    def test_user_cancel_absolute_deadline_unpaid_no_subevents(self):
+        assert self.order.user_cancel_deadline is None
+        self.event.settings.set('cancel_allow_user_until', RelativeDateWrapper(
+            now() + timedelta(days=1)
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline > now()
+        assert self.order.user_cancel_allowed
+        self.event.settings.set('cancel_allow_user_until', RelativeDateWrapper(
+            now() - timedelta(days=1)
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline < now()
+        assert not self.order.user_cancel_allowed
+
+    def test_user_cancel_relative_deadline_unpaid_no_subevents(self):
+        self.event.date_from = now() + timedelta(days=3)
+        self.event.save()
+
+        assert self.order.user_cancel_deadline is None
+        self.event.settings.set('cancel_allow_user_until', RelativeDateWrapper(
+            RelativeDate(days_before=2, time=datetime.time(14, 0, 0), base_date_name='date_from')
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline > now()
+        assert self.order.user_cancel_allowed
+        self.event.settings.set('cancel_allow_user_until', RelativeDateWrapper(
+            RelativeDate(days_before=4, time=datetime.time(14, 0, 0), base_date_name='date_from')
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline < now()
+        assert not self.order.user_cancel_allowed
+
+    def test_user_cancel_absolute_deadline_paid_no_subevents(self):
+        self.order.status = Order.STATUS_PAID
+        self.order.save()
+        self.event.settings.cancel_allow_user_paid = True
+        assert self.order.user_cancel_deadline is None
+        self.event.settings.set('cancel_allow_user_paid_until', RelativeDateWrapper(
+            now() + timedelta(days=1)
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_allowed
+        assert self.order.user_cancel_deadline > now()
+        self.event.settings.set('cancel_allow_user_paid_until', RelativeDateWrapper(
+            now() - timedelta(days=1)
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline < now()
+        assert not self.order.user_cancel_allowed
+
+    def test_user_cancel_relative_deadline_paid_no_subevents(self):
+        self.order.status = Order.STATUS_PAID
+        self.order.save()
+        self.event.date_from = now() + timedelta(days=3)
+        self.event.save()
+        self.event.settings.cancel_allow_user_paid = True
+
+        assert self.order.user_cancel_deadline is None
+        self.event.settings.set('cancel_allow_user_paid_until', RelativeDateWrapper(
+            RelativeDate(days_before=2, time=datetime.time(14, 0, 0), base_date_name='date_from')
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline > now()
+        assert self.order.user_cancel_allowed
+        self.event.settings.set('cancel_allow_user_paid_until', RelativeDateWrapper(
+            RelativeDate(days_before=4, time=datetime.time(14, 0, 0), base_date_name='date_from')
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline < now()
+        assert not self.order.user_cancel_allowed
+
+    def test_user_cancel_relative_deadline_to_subevents(self):
+        self.event.date_from = now() + timedelta(days=3)
+        self.event.has_subevents = True
+        self.event.save()
+        se1 = self.event.subevents.create(name="SE1", date_from=now() + timedelta(days=10))
+        se2 = self.event.subevents.create(name="SE2", date_from=now() + timedelta(days=1))
+        self.op1.subevent = se1
+        self.op1.save()
+        self.op2.subevent = se2
+        self.op2.save()
+
+        self.event.settings.set('cancel_allow_user_until', RelativeDateWrapper(
+            RelativeDate(days_before=2, time=datetime.time(14, 0, 0), base_date_name='date_from')
+        ))
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline < now()
+        self.op2.subevent = se1
+        self.op2.save()
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_deadline > now()
+
+    def test_user_cancel_fee(self):
+        self.order.fees.create(fee_type=OrderFee.FEE_TYPE_SHIPPING, value=Decimal('2.00'))
+        self.order.total = 48
+        self.order.save()
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_fee == Decimal('0.00')
+
+        self.event.settings.cancel_allow_user_paid_keep = Decimal('2.50')
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_fee == Decimal('2.50')
+
+        self.event.settings.cancel_allow_user_paid_keep_percentage = Decimal('10.0')
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_fee == Decimal('7.30')
+
+        self.event.settings.cancel_allow_user_paid_keep_fees = True
+        self.order = Order.objects.get(pk=self.order.pk)
+        assert self.order.user_cancel_fee == Decimal('9.30')
 
     def test_paid_order_underpaid(self):
         self.order.status = Order.STATUS_PAID
@@ -1044,6 +1174,43 @@ class OrderTestCase(BaseQuotaTestCase):
         assert self.order.positions.count() == 1
         assert self.order.all_positions.count() == 2
 
+    def test_propose_auto_refunds(self):
+        p1 = self.order.payments.create(
+            amount=Decimal('23.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy_fullrefund'
+        )
+        p2 = self.order.payments.create(
+            amount=Decimal('10.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy_partialrefund'
+        )
+        self.order.payments.create(
+            amount=Decimal('13.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy'
+        )
+        assert self.order.propose_auto_refunds(Decimal('23.00')) == {
+            p1: Decimal('23.00')
+        }
+        assert self.order.propose_auto_refunds(Decimal('10.00')) == {
+            p2: Decimal('10.00')
+        }
+        assert self.order.propose_auto_refunds(Decimal('5.00')) == {
+            p2: Decimal('5.00')
+        }
+        assert self.order.propose_auto_refunds(Decimal('20.00')) == {
+            p2: Decimal('10.00')
+        }
+        assert self.order.propose_auto_refunds(Decimal('25.00')) == {
+            p1: Decimal('23.00'),
+            p2: Decimal('2.00'),
+        }
+        assert self.order.propose_auto_refunds(Decimal('35.00')) == {
+            p1: Decimal('23.00'),
+            p2: Decimal('10.00'),
+        }
+
 
 class ItemCategoryTest(TestCase):
     """

src/tests/base/test_orders.py

@@ -18,8 +18,8 @@ from pretix.base.payment import FreeOrderProvider
 from pretix.base.reldate import RelativeDate, RelativeDateWrapper
 from pretix.base.services.invoices import generate_invoice
 from pretix.base.services.orders import (
-    OrderChangeManager, OrderError, _create_order, approve_order, deny_order,
-    expire_orders, send_download_reminders, send_expiry_warnings,
+    OrderChangeManager, OrderError, _create_order, approve_order, cancel_order,
+    deny_order, expire_orders, send_download_reminders, send_expiry_warnings,
 )
 
 
@@ -401,6 +401,132 @@ class DownloadReminderTests(TestCase):
         assert len(djmail.outbox) == 0
 
 
+class OrderCancelTests(TestCase):
+    def setUp(self):
+        super().setUp()
+        o = Organizer.objects.create(name='Dummy', slug='dummy')
+        self.event = Event.objects.create(organizer=o, name='Dummy', slug='dummy', date_from=now(),
+                                          plugins='tests.testdummy')
+        self.order = Order.objects.create(
+            code='FOO', event=self.event, email='dummy@dummy.test',
+            status=Order.STATUS_PENDING, locale='en',
+            datetime=now(), expires=now() + timedelta(days=10),
+            total=Decimal('46.00'),
+        )
+        self.ticket = Item.objects.create(event=self.event, name='Early-bird ticket',
+                                          default_price=Decimal('23.00'), admission=True)
+        self.op1 = OrderPosition.objects.create(
+            order=self.order, item=self.ticket, variation=None,
+            price=Decimal("23.00"), attendee_name_parts={'full_name': "Peter"}, positionid=1
+        )
+        self.op2 = OrderPosition.objects.create(
+            order=self.order, item=self.ticket, variation=None,
+            price=Decimal("23.00"), attendee_name_parts={'full_name': "Dieter"}, positionid=2
+        )
+        generate_invoice(self.order)
+        djmail.outbox = []
+
+    def test_cancel_canceled(self):
+        self.order.status = Order.STATUS_CANCELED
+        self.order.save()
+        with pytest.raises(OrderError):
+            cancel_order(self.order.pk)
+
+    def test_cancel_send_mail(self):
+        cancel_order(self.order.pk, send_mail=True)
+        assert len(djmail.outbox) == 1
+
+    def test_cancel_send_no_mail(self):
+        cancel_order(self.order.pk, send_mail=False)
+        assert len(djmail.outbox) == 0
+
+    def test_cancel_unpaid(self):
+        cancel_order(self.order.pk)
+        self.order.refresh_from_db()
+        assert self.order.status == Order.STATUS_CANCELED
+        assert self.order.all_logentries().last().action_type == 'pretix.event.order.canceled'
+        assert self.order.invoices.count() == 2
+
+    def test_cancel_unpaid_with_voucher(self):
+        self.op1.voucher = self.event.vouchers.create(item=self.ticket, redeemed=1)
+        self.op1.save()
+        cancel_order(self.order.pk)
+        self.order.refresh_from_db()
+        assert self.order.status == Order.STATUS_CANCELED
+        assert self.order.all_logentries().last().action_type == 'pretix.event.order.canceled'
+        self.op1.voucher.refresh_from_db()
+        assert self.op1.voucher.redeemed == 0
+        assert self.order.invoices.count() == 2
+
+    def test_cancel_paid(self):
+        self.order.status = Order.STATUS_PAID
+        self.order.save()
+        cancel_order(self.order.pk)
+        self.order.refresh_from_db()
+        assert self.order.status == Order.STATUS_CANCELED
+        assert self.order.all_logentries().last().action_type == 'pretix.event.order.canceled'
+        assert self.order.invoices.count() == 2
+
+    def test_cancel_paid_with_too_high_fee(self):
+        self.order.status = Order.STATUS_PAID
+        self.order.save()
+        self.order.payments.create(state=OrderPayment.PAYMENT_STATE_CONFIRMED, amount=48.5)
+        with pytest.raises(OrderError):
+            cancel_order(self.order.pk, cancellation_fee=50)
+        self.order.refresh_from_db()
+        assert self.order.status == Order.STATUS_PAID
+        assert self.order.total == 46
+
+    def test_cancel_paid_with_fee(self):
+        f = self.order.fees.create(fee_type=OrderFee.FEE_TYPE_SHIPPING, value=2.5)
+        self.order.status = Order.STATUS_PAID
+        self.order.total = 48.5
+        self.order.save()
+        self.order.payments.create(state=OrderPayment.PAYMENT_STATE_CONFIRMED, amount=48.5)
+        self.op1.voucher = self.event.vouchers.create(item=self.ticket, redeemed=1)
+        self.op1.save()
+        cancel_order(self.order.pk, cancellation_fee=2.5)
+        self.order.refresh_from_db()
+        assert self.order.status == Order.STATUS_PAID
+        self.op1.refresh_from_db()
+        assert self.op1.canceled
+        self.op2.refresh_from_db()
+        assert self.op2.canceled
+        f.refresh_from_db()
+        assert f.canceled
+        assert self.order.total == 2.5
+        assert self.order.all_logentries().last().action_type == 'pretix.event.order.canceled'
+        self.op1.voucher.refresh_from_db()
+        assert self.op1.voucher.redeemed == 0
+        assert self.order.invoices.count() == 3
+        assert not self.order.invoices.last().is_cancellation
+
+    def test_auto_refund_possible(self):
+        p1 = self.order.payments.create(
+            amount=Decimal('46.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy_partialrefund'
+        )
+        cancel_order(self.order.pk, cancellation_fee=2, try_auto_refund=True)
+        r = self.order.refunds.get()
+        assert r.state == OrderRefund.REFUND_STATE_DONE
+        assert r.amount == Decimal('44.00')
+        assert r.source == OrderRefund.REFUND_SOURCE_BUYER
+        assert r.payment == p1
+        assert self.order.all_logentries().filter(action_type='pretix.event.order.refund.created').exists()
+        assert not self.order.all_logentries().filter(action_type='pretix.event.order.refund.requested').exists()
+
+    def test_auto_refund_impossible(self):
+        self.order.payments.create(
+            amount=Decimal('46.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy_fullrefund'
+        )
+        cancel_order(self.order.pk, cancellation_fee=2, try_auto_refund=True)
+        assert not self.order.refunds.exists()
+        assert self.order.all_logentries().filter(action_type='pretix.event.order.refund.requested').exists()
+
+
 class OrderChangeManagerTests(TestCase):
     def setUp(self):
         super().setUp()