def test_abnormal_address_data(self, mock_client):
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
patch.object(DocdataPaymentAdapter, 'create_payment',
fake_create_payment)
user = BlueBottleUserFactory()
CountryFactory(name='Netherlands', alpha2_code='NL')
# Update user address with abnormal line1
user.address.line1 = '1a'
user.address.save()
self.order = OrderFactory.create(user=user)
self.order_payment = OrderPaymentFactory.create(
order=self.order,
payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(order_payment=self.order_payment)
user_data = self.service.adapter.get_user_data()
self.assertEqual(user_data['street'], 'Unknown')
def test_incomplete_userdata(self, mock_client):
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
patch.object(DocdataPaymentAdapter, 'create_payment',
fake_create_payment)
user = BlueBottleUserFactory()
self.order = OrderFactory.create(user=user)
self.order_payment = OrderPaymentFactory.create(
order=self.order,
payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(order_payment=self.order_payment)
user_data = self.service.adapter.get_user_data()
self.assertEqual(user_data['id'], user.id)
self.assertEqual(user_data['first_name'], user.first_name)
self.assertEqual(user_data['last_name'], user.last_name)
self.assertEqual(user_data['email'], user.email)
self.assertEqual(user_data['street'], 'Unknown')
self.assertEqual(user_data['house_number'], 'Unknown')
self.assertEqual(user_data['postal_code'], 'Unknown')
self.assertEqual(user_data['city'], 'Unknown')
self.assertEqual(user_data['country'], 'NL')
self.assertEqual(user_data['company'], '')
self.assertEqual(user_data['kvk_number'], '')
self.assertEqual(user_data['vat_number'], '')
self.assertEqual(user_data['house_number_addition'], '')
self.assertEqual(user_data['state'], '')
def test_order_status_can_pledge(self):
"""
User with can_pledge setting enabled is allowed to pledge
"""
PaymentService(order_payment=self.order_payment)
# Check that the status propagated through to order
self.assert_status(self.order, StatusDefinition.PLEDGED)
def get_redirect_url(self, *args, **kwargs):
order_payment = get_object_or_404(OrderPayment,
id=kwargs['order_payment_id'])
service = PaymentService(order_payment)
service.check_payment_status()
return "{0}/orders/{1}/success".format(get_current_host(),
order_payment.order.id)
def check_status_psp(self, order):
try:
order_payment = order.order_payments.all().order_by('-created')[0]
except IndexError:
raise Http404
service = PaymentService(order_payment)
service.adapter.check_payment_status()
def test_fixed_transaction_fee(self):
"""
Check that the flat 0.75 mockIdeal fee is set
"""
self.order_payment.payment_method = 'mockIdeal'
self.order_payment.save()
PaymentService(self.order_payment)
self.assertEqual(self.order_payment.transaction_fee, 0.75)
def test_no_success_payment_status_check(self, mock_check_payment_status):
self.order = OrderFactory.create(user=self.user1, total=15)
self.order_payment = OrderPaymentFactory.create(order=self.order,
payment_method='mock')
self.service = PaymentService(order_payment=self.order_payment)
self.client.get(reverse('order-manage-detail',
kwargs={'pk': self.order.id}),
token=self.user1_token)
self.assertEqual(mock_check_payment_status.called, True)
def refund_project(tenant, project):
with LocalTenant(tenant, clear_tenant=True):
for donation in project.donations:
service = PaymentService(donation.order.order_payment)
try:
service.refund_payment()
except Exception:
# Don't trip if one refund throws an error
pass
def setUp(self):
super(PaymentsMockTestCase, self).setUp()
self.init_projects()
self.order = OrderFactory.create(total=35)
self.order_payment = OrderPaymentFactory.create(order=self.order,
payment_method='mock')
self.service = PaymentService(order_payment=self.order_payment)
def test_relative_transaction_fee(self):
"""
Check that the 3.25% mockCard fee is calculated
"""
self.assertEqual(self.order.total.amount, 60)
self.order_payment.payment_method = 'mockCard'
self.order_payment.save()
PaymentService(self.order_payment)
self.assertEqual(self.order_payment.transaction_fee, 1.95)
def test_order_status_cannot_pledge(self):
"""
Normal user can not pledge
"""
self.user.can_pledge = False
self.user.save()
with self.assertRaises(PaymentException):
self.service = PaymentService(order_payment=self.order_payment)
def test_refund(self):
"""
User with can_pledge setting enabled is allowed to pledge
"""
service = PaymentService(order_payment=self.order_payment)
service.refund_payment()
# Check that the status propagated through to order
self.assert_status(self.order_payment, StatusDefinition.REFUNDED)
def perform_update(self, serializer):
serializer.save(amount=serializer.validated_data['order'].total)
# store integration_data in non-persisted card_data field
serializer.instance.card_data = serializer.validated_data[
'integration_data']
service = PaymentService(serializer.instance)
try:
service.check_payment_status()
except PaymentException as error:
raise ParseError(detail=str(error))
def post(self, request, *args, **kwargs):
payload = json.loads(request.body)
try:
payment = FlutterwaveMpesaPayment.objects.get(
account_number=payload['billrefnumber'])
except FlutterwaveMpesaPayment.DoesNotExist:
raise Http404('No payment found with this billrefnumber.')
service = PaymentService(payment.order_payment)
service.adapter.update_mpesa(**payload)
return HttpResponse(status=200, content={'success': 1})
def check_payment_statuses(order_payments, tenant):
connection.set_tenant(tenant)
with LocalTenant(tenant, clear_tenant=True):
for order_payment in order_payments:
service = PaymentService(order_payment)
try:
service.check_payment_status()
except (PaymentException, TypeError):
pass
def test_changing_fee_when_changing_payment_method(self):
"""
Check that the fee changes when we change payment method
"""
self.order_payment.payment_method = 'mockIdeal'
self.order_payment.save()
PaymentService(self.order_payment)
self.assertEqual(self.order_payment.transaction_fee, 0.75)
self.order_payment.payment_method = 'mockCard'
self.order_payment.save()
self.assertEqual(self.order_payment.transaction_fee, 1.95)
def post(self, request, *args, **kwargs):
payload = json.loads(request.body)['data']
transaction_reference = payload["collection_request"]["id"]
payment = get_object_or_404(
BeyonicPayment, transaction_reference=transaction_reference)
service = PaymentService(payment.order_payment)
try:
service.check_payment_status()
return HttpResponse('success')
except PaymentException:
return HttpResponse('success')
def check_status(self, request, pk=None):
order_payment = OrderPayment.objects.get(pk=pk)
service = PaymentService(order_payment)
try:
service.check_payment_status()
except PaymentException as e:
self.message_user(request,
'Error checking status {}'.format(e),
level='WARNING')
order_payment_url = reverse('admin:payments_orderpayment_change',
args=(order_payment.id, ))
response = HttpResponseRedirect(order_payment_url)
return response
def setUp(self, mock_client):
super(TestPaymentLogger, self).setUp()
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
self.order = OrderFactory.create(total=35)
self.order_payment = OrderPaymentFactory.create(
payment_method='docdataIdeal',
order=self.order,
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(self.order_payment)
def post(self, request, *args, **kwargs):
status = request.POST.get('status', None)
order_payment_id = request.POST.get('order_payment_id')
try:
order_payment = OrderPayment.objects.get(id=order_payment_id)
except OrderPayment.DoesNotExist:
raise Http404
service = PaymentService(order_payment)
# We pass the MockPayment status and get back the status name of our OrderStatus definition
service.adapter.set_order_payment_new_status(status)
return HttpResponse('success')
def setUp(self, mock_client):
super(PaymentsDocdataTestCase, self).setUp()
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
# Mock create payment
patch.object(DocdataPaymentAdapter, 'create_payment',
fake_create_payment)
self.order = OrderFactory.create()
self.order_payment = OrderPaymentFactory.create(
order=self.order,
payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(order_payment=self.order_payment)
def perform_create(self, serializer):
if self.request.user and self.request.user.is_authenticated():
serializer.save(user=self.request.user)
if not serializer.instance.order.user:
serializer.instance.order.user = self.request.user
serializer.instance.order.save()
else:
serializer.save()
try:
service = PaymentService(serializer.instance)
service.start_payment()
except PaymentException as error:
raise ParseError(detail=str(error))
def test_normal_userdata(self, mock_client):
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
patch.object(DocdataPaymentAdapter, 'create_payment',
fake_create_payment)
user = BlueBottleUserFactory()
holland = CountryFactory(name='Netherlands', alpha2_code='NL')
# Update user address
user.address.line1 = 'Dam 1a'
user.address.line2 = 'Bovenste bel'
user.address.city = 'Amsterdam'
user.address.postal_code = '1000AA'
user.address.country = holland
user.address.save()
self.order = OrderFactory.create(user=user)
self.order_payment = OrderPaymentFactory.create(
order=self.order,
payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(order_payment=self.order_payment)
user_data = self.service.adapter.get_user_data()
self.assertEqual(user_data['id'], user.id)
self.assertEqual(user_data['first_name'], user.first_name)
self.assertEqual(user_data['last_name'], user.last_name)
self.assertEqual(user_data['email'], user.email)
self.assertEqual(user_data['street'], 'Dam')
self.assertEqual(user_data['house_number'], '1a')
self.assertEqual(user_data['postal_code'], '1000AA')
self.assertEqual(user_data['city'], 'Amsterdam')
self.assertEqual(user_data['country'], 'NL')
self.assertEqual(user_data['company'], '')
self.assertEqual(user_data['kvk_number'], '')
self.assertEqual(user_data['vat_number'], '')
self.assertEqual(user_data['house_number_addition'], '')
self.assertEqual(user_data['state'], '')
def refund(self, request, pk=None):
if not request.user.has_perm('payments.refund_orderpayment'
) or not properties.ENABLE_REFUNDS:
return HttpResponseForbidden(
'Missing permission: payments.refund_orderpayment')
order_payment = OrderPayment.objects.get(pk=pk)
service = PaymentService(order_payment)
service.refund_payment()
self.message_user(request, 'Refund is requested.')
order_payment_url = reverse('admin:payments_orderpayment_change',
args=(order_payment.id, ))
response = HttpResponseRedirect(order_payment_url)
return response
def test_refund_pledged_payment(self):
user = BlueBottleUserFactory.create(can_pledge=True)
order = OrderFactory.create(user=user)
order_payment = OrderPaymentFactory.create(
order=order, user=user, payment_method='pledgeStandard')
DonationFactory.create(
project=self.project,
order=order,
amount=Money(100, 'EUR'),
)
PaymentService(order_payment=order_payment)
with mock.patch.object(DocdataPaymentAdapter,
'refund_payment',
side_effect=self.mock_side_effect):
refund_project(connection.tenant, self.project)
order = Order.objects.get(pk=order.pk)
self.assertEqual(order.status, 'cancelled')
def get(self, request, **kwargs):
merchant_order_id = kwargs['merchant_order_id']
try:
# Try to load new style OrderPayment
order_payment_id = merchant_order_id.split('-')[0]
order_payment = OrderPayment.objects.get(pk=order_payment_id)
except OrderPayment.DoesNotExist:
# Try to load old style DocdataPayment.
try:
payment = DocdataPayment.objects.get(
merchant_order_id=merchant_order_id)
order_payment = payment.order_payment
except DocdataPayment.DoesNotExist:
raise Exception(
"Couldn't find Payment for merchant_order_id: {0}".format(
merchant_order_id))
service = PaymentService(order_payment)
service.check_payment_status()
return HttpResponse('success')
def post(self, request, *args, **kwargs):
success = 'success' in request.POST
failure = 'failure' in request.POST
authenticity = request.POST.get('authenticity')
order_id = request.POST.get('order_id')
try:
payment = VitepayPayment.objects.get(order_id=order_id)
order_payment = payment.order_payment
except VitepayPayment.DoesNotExist:
return HttpResponse('{"status": "0", "message": "Order not found."}')
service = PaymentService(order_payment)
# We pass the post params to the adapter to do the status update
try:
service.adapter.status_update(authenticity, success, failure)
return HttpResponse('{"status": "1"}')
except PaymentException as e:
return HttpResponse('{"status": "0", "message": "%s"}' % e)
def _order_requested(sender, order, **kwargs):
# Check the status at PSP if status is still locked
if order.status == StatusDefinition.LOCKED:
order_payment = OrderPayment.get_latest_by_order(order)
service = PaymentService(order_payment)
service.check_payment_status()
def _process_monthly_order(monthly_order, send_email=False):
if monthly_order.processed:
logger.info("Order for {0} already processed".format(
monthly_order.user))
return {'order_payment_id': None, 'processed': True}
order_success = [StatusDefinition.PENDING, StatusDefinition.SUCCESS]
ten_days_ago = timezone.now() + timezone.timedelta(days=-10)
recent_orders = Order.objects.filter(user=monthly_order.user,
order_type='recurring',
status__in=order_success,
updated__gt=ten_days_ago)
if recent_orders.count() > 0:
message = "Skipping '{0}' recently processed a recurring order for {1}:".format(
monthly_order, monthly_order.user)
logger.warn(message)
for closed_order in recent_orders.all():
logger.warn("Recent Order Number: {0}".format(closed_order.id))
# Set an error on this monthly order
monthly_order.error = message
monthly_order.save()
return {'order_payment_id': None, 'processed': False}
order = Order.objects.create(status=StatusDefinition.LOCKED,
user=monthly_order.user,
order_type='recurring')
order.save()
logger.info("Creating Order for {0} with {1} donations".format(
monthly_order.user, monthly_order.donations.count()))
for monthly_donation in monthly_order.donations.all():
donation = Donation.objects.create(amount=monthly_donation.amount,
project=monthly_donation.project,
order=order)
donation.save()
integration_data = {
'account_name': monthly_order.name,
'account_city': monthly_order.city,
'iban': monthly_order.iban,
'bic': monthly_order.bic,
'agree': True
}
order_payment = OrderPayment(order=order,
user=monthly_order.user,
payment_method=PAYMENT_METHOD,
integration_data=integration_data)
order_payment.save()
try:
service = PaymentService(order_payment)
service.start_payment()
except PaymentException as e:
error_message = "Problem starting payment. {0}".format(e)
monthly_order.error = "{0}".format(e.message)
monthly_order.save()
logger.error(error_message)
return {'order_payment_id': order_payment.id, 'processed': False}
logger.debug("Payment for '{0}' started.".format(monthly_order))
monthly_order.processed = True
monthly_order.error = ''
monthly_order.save()
# Try to update status
service.check_payment_status()
# Send an email to the user.
if send_email:
mail_monthly_donation_processed_notification(monthly_order)
return {'order_payment_id': order_payment.id, 'processed': True}
def reload_status(self, request, queryset):
for order in queryset.all():
for order_payment in order.order_payments.all():
service = PaymentService(order_payment)
service.check_payment_status()
