From 2eaaad49db737157f8a86682e78cbc3f0c4c6b8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 10:59:21 +0100 Subject: [PATCH 01/11] Handle setup fee in bills --- uncloud/uncloud_pay/models.py | 15 +++++++++------ uncloud/uncloud_pay/serializers.py | 1 + 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 8964cb3..24cc858 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -167,22 +167,25 @@ class BillRecord(): self.bill.starting_date.year, self.bill.starting_date.month) adjusted_recurring_price = self.recurring_price / days_in_month - recurring_price = adjusted_recurring_price * days - - return self.recurring_price # TODO + amount = adjusted_recurring_price * days elif self.recurring_period == RecurringPeriod.PER_DAY: days = ceil(billed_delta / timedelta(days=1)) - return self.recurring_price * days + amount = self.recurring_price * days elif self.recurring_period == RecurringPeriod.PER_HOUR: hours = ceil(billed_delta / timedelta(hours=1)) - return self.recurring_price * hours + amount = self.recurring_price * hours elif self.recurring_period == RecurringPeriod.PER_SECOND: seconds = ceil(billed_delta / timedelta(seconds=1)) - return self.recurring_price * seconds + amount = self.recurring_price * seconds else: raise Exception('Unsupported recurring period: {}.'. format(record.recurring_period)) + if self.order.starting_date > self.bill.starting_date: + amount += self.setup_fee + + return amount + ### # Orders. diff --git a/uncloud/uncloud_pay/serializers.py b/uncloud/uncloud_pay/serializers.py index 6e4b2d3..fcbaf73 100644 --- a/uncloud/uncloud_pay/serializers.py +++ b/uncloud/uncloud_pay/serializers.py @@ -96,6 +96,7 @@ class BillRecordSerializer(serializers.Serializer): description = serializers.CharField() recurring_period = serializers.CharField() recurring_price = serializers.DecimalField(max_digits=10, decimal_places=2) + setup_fee = serializers.DecimalField(max_digits=10, decimal_places=2) amount = serializers.DecimalField(max_digits=10, decimal_places=2) class BillSerializer(serializers.ModelSerializer): From a40da401692a0e8591984cc38c21401e1445d986 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 11:15:48 +0100 Subject: [PATCH 02/11] Add recurring_count to bills --- uncloud/uncloud_pay/models.py | 18 +++++++++++------- uncloud/uncloud_pay/serializers.py | 1 + 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 24cc858..4e5770a 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -8,6 +8,7 @@ from math import ceil from datetime import timedelta from calendar import monthrange +from decimal import Decimal import uuid # Define DecimalField properties, used to represent amounts of money. @@ -113,7 +114,7 @@ class Bill(models.Model): @property def total(self): - return reduce(lambda acc, record: acc + record.amount(), self.records, 0) + return reduce(lambda acc, record: acc + record.amount, self.records, 0) @property def final(self): @@ -133,7 +134,8 @@ class BillRecord(): self.recurring_period = order_record.recurring_period self.description = order_record.description - def amount(self): + @property + def recurring_count(self): # Compute billing delta. billed_until = self.bill.ending_date if self.order.ending_date != None and self.order.ending_date < self.order.ending_date: @@ -166,21 +168,23 @@ class BillRecord(): (_, days_in_month) = monthrange( self.bill.starting_date.year, self.bill.starting_date.month) - adjusted_recurring_price = self.recurring_price / days_in_month - amount = adjusted_recurring_price * days + return Decimal(days / days_in_month) elif self.recurring_period == RecurringPeriod.PER_DAY: days = ceil(billed_delta / timedelta(days=1)) - amount = self.recurring_price * days + return Decimal(days) elif self.recurring_period == RecurringPeriod.PER_HOUR: hours = ceil(billed_delta / timedelta(hours=1)) - amount = self.recurring_price * hours + return Decimal(hours) elif self.recurring_period == RecurringPeriod.PER_SECOND: seconds = ceil(billed_delta / timedelta(seconds=1)) - amount = self.recurring_price * seconds + return Decimal(seconds) else: raise Exception('Unsupported recurring period: {}.'. format(record.recurring_period)) + @property + def amount(self): + amount = self.recurring_count * self.recurring_price if self.order.starting_date > self.bill.starting_date: amount += self.setup_fee diff --git a/uncloud/uncloud_pay/serializers.py b/uncloud/uncloud_pay/serializers.py index fcbaf73..051b882 100644 --- a/uncloud/uncloud_pay/serializers.py +++ b/uncloud/uncloud_pay/serializers.py @@ -96,6 +96,7 @@ class BillRecordSerializer(serializers.Serializer): description = serializers.CharField() recurring_period = serializers.CharField() recurring_price = serializers.DecimalField(max_digits=10, decimal_places=2) + recurring_count = serializers.DecimalField(max_digits=10, decimal_places=2) setup_fee = serializers.DecimalField(max_digits=10, decimal_places=2) amount = serializers.DecimalField(max_digits=10, decimal_places=2) From 11e22f5001cf7469f5a28974b411a566f3740509 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 11:27:35 +0100 Subject: [PATCH 03/11] Consistently use one_time_price instead of setup_fee --- .../migrations/0014_auto_20200303_1027.py | 18 +++++++++++++ uncloud/uncloud_pay/models.py | 26 ++++++++++--------- uncloud/uncloud_pay/serializers.py | 6 ++--- uncloud/uncloud_vm/views.py | 2 +- uncloud/ungleich_service/models.py | 2 +- uncloud/ungleich_service/views.py | 4 +-- 6 files changed, 39 insertions(+), 19 deletions(-) create mode 100644 uncloud/uncloud_pay/migrations/0014_auto_20200303_1027.py diff --git a/uncloud/uncloud_pay/migrations/0014_auto_20200303_1027.py b/uncloud/uncloud_pay/migrations/0014_auto_20200303_1027.py new file mode 100644 index 0000000..05759d1 --- /dev/null +++ b/uncloud/uncloud_pay/migrations/0014_auto_20200303_1027.py @@ -0,0 +1,18 @@ +# Generated by Django 3.0.3 on 2020-03-03 10:27 + +from django.db import migrations + + +class Migration(migrations.Migration): + + dependencies = [ + ('uncloud_pay', '0013_paymentmethod_stripe_card_id'), + ] + + operations = [ + migrations.RenameField( + model_name='orderrecord', + old_name='setup_fee', + new_name='one_time_price', + ), + ] diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 4e5770a..551b96d 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -129,11 +129,15 @@ class BillRecord(): def __init__(self, bill, order_record): self.bill = bill self.order = order_record.order - self.setup_fee = order_record.setup_fee self.recurring_price = order_record.recurring_price self.recurring_period = order_record.recurring_period self.description = order_record.description + if self.order.starting_date > self.bill.starting_date: + self.one_time_price = one_time_price + else: + self.one_time_price = 0 + @property def recurring_count(self): # Compute billing delta. @@ -178,17 +182,15 @@ class BillRecord(): elif self.recurring_period == RecurringPeriod.PER_SECOND: seconds = ceil(billed_delta / timedelta(seconds=1)) return Decimal(seconds) + elif self.recurring_period == RecurringPeriod.ONE_TIME: + return Decimal(0) else: raise Exception('Unsupported recurring period: {}.'. format(record.recurring_period)) @property def amount(self): - amount = self.recurring_count * self.recurring_price - if self.order.starting_date > self.bill.starting_date: - amount += self.setup_fee - - return amount + return self.recurring_price * self.recurring_count + self.one_time_price ### # Orders. @@ -231,22 +233,22 @@ class Order(models.Model): return OrderRecord.objects.filter(order=self) @property - def setup_fee(self): - return reduce(lambda acc, record: acc + record.setup_fee, self.records, 0) + def one_time_price(self): + return reduce(lambda acc, record: acc + record.one_time_price, self.records, 0) @property def recurring_price(self): return reduce(lambda acc, record: acc + record.recurring_price, self.records, 0) - def add_record(self, setup_fee, recurring_price, description): + def add_record(self, one_time_price, recurring_price, description): OrderRecord.objects.create(order=self, - setup_fee=setup_fee, + one_time_price=one_time_price, recurring_price=recurring_price, description=description) class OrderRecord(models.Model): order = models.ForeignKey(Order, on_delete=models.CASCADE) - setup_fee = models.DecimalField(default=0.0, + one_time_price = models.DecimalField(default=0.0, max_digits=AMOUNT_MAX_DIGITS, decimal_places=AMOUNT_DECIMALS, validators=[MinValueValidator(0)]) @@ -303,7 +305,7 @@ class Product(models.Model): pass # To be implemented in child. @property - def setup_fee(self): + def one_time_price(self): return 0 @property diff --git a/uncloud/uncloud_pay/serializers.py b/uncloud/uncloud_pay/serializers.py index 051b882..16b725a 100644 --- a/uncloud/uncloud_pay/serializers.py +++ b/uncloud/uncloud_pay/serializers.py @@ -97,7 +97,7 @@ class BillRecordSerializer(serializers.Serializer): recurring_period = serializers.CharField() recurring_price = serializers.DecimalField(max_digits=10, decimal_places=2) recurring_count = serializers.DecimalField(max_digits=10, decimal_places=2) - setup_fee = serializers.DecimalField(max_digits=10, decimal_places=2) + one_time_price = serializers.DecimalField(max_digits=10, decimal_places=2) amount = serializers.DecimalField(max_digits=10, decimal_places=2) class BillSerializer(serializers.ModelSerializer): @@ -113,7 +113,7 @@ class BillSerializer(serializers.ModelSerializer): class OrderRecordSerializer(serializers.ModelSerializer): class Meta: model = OrderRecord - fields = ['setup_fee', 'recurring_price', 'description'] + fields = ['one_time_price', 'recurring_price', 'description'] class OrderSerializer(serializers.ModelSerializer): @@ -121,7 +121,7 @@ class OrderSerializer(serializers.ModelSerializer): class Meta: model = Order fields = ['uuid', 'creation_date', 'starting_date', 'ending_date', - 'bill', 'recurring_period', 'records', 'recurring_price', 'setup_fee'] + 'bill', 'recurring_period', 'records', 'recurring_price', 'one_time_price'] class ProductSerializer(serializers.Serializer): vms = VMProductSerializer(many=True, read_only=True) diff --git a/uncloud/uncloud_vm/views.py b/uncloud/uncloud_vm/views.py index 107f23e..d9a5732 100644 --- a/uncloud/uncloud_vm/views.py +++ b/uncloud/uncloud_vm/views.py @@ -49,7 +49,7 @@ class VMProductViewSet(ProductViewSet): # Add Product record to order (VM is mutable, allows to keep history in order). # XXX: Move this to some kind of on_create hook in parent Product class? - order.add_record(vm.setup_fee, + order.add_record(vm.one_time_price, vm.recurring_price(order.recurring_period), vm.description) return Response(serializer.data) diff --git a/uncloud/ungleich_service/models.py b/uncloud/ungleich_service/models.py index 8f95973..9d6a8ac 100644 --- a/uncloud/ungleich_service/models.py +++ b/uncloud/ungleich_service/models.py @@ -28,5 +28,5 @@ class MatrixServiceProduct(Product): RecurringPeriod.choices)) @property - def setup_fee(self): + def one_time_price(self): return 30 diff --git a/uncloud/ungleich_service/views.py b/uncloud/ungleich_service/views.py index d5191a2..47c15e2 100644 --- a/uncloud/ungleich_service/views.py +++ b/uncloud/ungleich_service/views.py @@ -41,7 +41,7 @@ class MatrixServiceProductViewSet(ProductViewSet): # XXX: Move this to some kind of on_create hook in parent # Product class? order.add_record( - vm.setup_fee, + vm.one_time_price, vm.recurring_price(order.recurring_period), vm.description) @@ -54,7 +54,7 @@ class MatrixServiceProductViewSet(ProductViewSet): # XXX: Move this to some kind of on_create hook in parent # Product class? order.add_record( - service.setup_fee, + service.one_time_price, service.recurring_price(order.recurring_period), service.description) From 53baf0d9f39a7a8679f94eb314507ea7e09fb20c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 11:29:57 +0100 Subject: [PATCH 04/11] Fix typo in BillRecord --- uncloud/uncloud_pay/models.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 551b96d..f4b8fdd 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -134,7 +134,7 @@ class BillRecord(): self.description = order_record.description if self.order.starting_date > self.bill.starting_date: - self.one_time_price = one_time_price + self.one_time_price = order_record.one_time_price else: self.one_time_price = 0 From 28407bf3e33723f2b1fda9ab44057b13e2012e51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 11:34:47 +0100 Subject: [PATCH 05/11] Quickly document OrderRecord class --- uncloud/uncloud_pay/models.py | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index f4b8fdd..62fa098 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -195,19 +195,8 @@ class BillRecord(): ### # Orders. -# /!\ BIG FAT WARNING /!\ # -# # Order are assumed IMMUTABLE and used as SOURCE OF TRUST for generating # bills. Do **NOT** mutate then! -# -# Why? We need to store the state somewhere since product are mutable (e.g. -# adding RAM to VM, changing price of 1GB of RAM, ...). An alternative could -# have been to only store the state in bills but would have been more -# confusing: the order is a 'contract' with the customer, were both parts -# agree on deal => That's what we want to keep archived. -# -# /!\ BIG FAT WARNING /!\ # - class Order(models.Model): uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) owner = models.ForeignKey(get_user_model(), @@ -247,6 +236,14 @@ class Order(models.Model): description=description) class OrderRecord(models.Model): + """ + Order records store billing informations for products: the actual product + might be mutated and/or moved to another order but we do not want to loose + the details of old orders. + + Used as source of trust to dynamically generate bill entries. + """ + order = models.ForeignKey(Order, on_delete=models.CASCADE) one_time_price = models.DecimalField(default=0.0, max_digits=AMOUNT_MAX_DIGITS, From 3846e493954db1435f82b1673c61f28e52b16a5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 11:40:37 +0100 Subject: [PATCH 06/11] Fix migration issue introduced in previous merge --- uncloud/uncloud_vm/migrations/0007_auto_20200228_1344.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/uncloud/uncloud_vm/migrations/0007_auto_20200228_1344.py b/uncloud/uncloud_vm/migrations/0007_auto_20200228_1344.py index 8867f2f..8b56a8b 100644 --- a/uncloud/uncloud_vm/migrations/0007_auto_20200228_1344.py +++ b/uncloud/uncloud_vm/migrations/0007_auto_20200228_1344.py @@ -10,11 +10,6 @@ class Migration(migrations.Migration): ] operations = [ - migrations.AddField( - model_name='vmnetworkcard', - name='ip_address', - field=models.GenericIPAddressField(blank=True, null=True), - ), migrations.AddField( model_name='vmproduct', name='status', From 94a39ed81de5094cca2d4f6afac4c5d4700ef54b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 16:55:56 +0100 Subject: [PATCH 07/11] Properly wire stripe card to payment methods --- .../migrations/0015_stripecustomer.py | 24 ++++++++++++ .../migrations/0016_auto_20200303_1552.py | 25 ++++++++++++ uncloud/uncloud_pay/models.py | 20 ++++++++++ uncloud/uncloud_pay/serializers.py | 39 ++----------------- uncloud/uncloud_pay/stripe.py | 24 ++++++++++-- uncloud/uncloud_pay/views.py | 28 +++++++++++-- 6 files changed, 117 insertions(+), 43 deletions(-) create mode 100644 uncloud/uncloud_pay/migrations/0015_stripecustomer.py create mode 100644 uncloud/uncloud_pay/migrations/0016_auto_20200303_1552.py diff --git a/uncloud/uncloud_pay/migrations/0015_stripecustomer.py b/uncloud/uncloud_pay/migrations/0015_stripecustomer.py new file mode 100644 index 0000000..14fdbf0 --- /dev/null +++ b/uncloud/uncloud_pay/migrations/0015_stripecustomer.py @@ -0,0 +1,24 @@ +# Generated by Django 3.0.3 on 2020-03-03 13:56 + +from django.conf import settings +from django.db import migrations, models +import django.db.models.deletion + + +class Migration(migrations.Migration): + + dependencies = [ + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ('uncloud_pay', '0014_auto_20200303_1027'), + ] + + operations = [ + migrations.CreateModel( + name='StripeCustomer', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('stripe_id', models.CharField(max_length=32)), + ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)), + ], + ), + ] diff --git a/uncloud/uncloud_pay/migrations/0016_auto_20200303_1552.py b/uncloud/uncloud_pay/migrations/0016_auto_20200303_1552.py new file mode 100644 index 0000000..08e3f2f --- /dev/null +++ b/uncloud/uncloud_pay/migrations/0016_auto_20200303_1552.py @@ -0,0 +1,25 @@ +# Generated by Django 3.0.3 on 2020-03-03 15:52 + +from django.conf import settings +from django.db import migrations, models +import django.db.models.deletion + + +class Migration(migrations.Migration): + + dependencies = [ + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ('uncloud_pay', '0015_stripecustomer'), + ] + + operations = [ + migrations.RemoveField( + model_name='stripecustomer', + name='id', + ), + migrations.AlterField( + model_name='stripecustomer', + name='owner', + field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, primary_key=True, serialize=False, to=settings.AUTH_USER_MODEL), + ), + ] diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 62fa098..fa775fc 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -7,6 +7,7 @@ from django.utils import timezone from math import ceil from datetime import timedelta from calendar import monthrange +import uncloud_pay.stripe from decimal import Decimal import uuid @@ -68,6 +69,20 @@ class PaymentMethod(models.Model): # Only used for "Stripe" source stripe_card_id = models.CharField(max_length=32, blank=True, null=True) + @property + def stripe_card_last4(self): + if self.source == 'stripe': + card_request = uncloud_pay.stripe.get_card( + StripeCustomer.objects.get(owner=self.owner).stripe_id, + self.stripe_card_id) + if card_request['error'] == None: + return card_request['response_object']['last4'] + else: + return None + else: + return None + + def charge(self, amount): if amount > 0: # Make sure we don't charge negative amount by errors... if self.source == 'stripe': @@ -85,6 +100,11 @@ class PaymentMethod(models.Model): class Meta: unique_together = [['owner', 'primary']] +class StripeCustomer(models.Model): + owner = models.OneToOneField( get_user_model(), + primary_key=True, + on_delete=models.CASCADE) + stripe_id = models.CharField(max_length=32) ### # Bills & Payments. diff --git a/uncloud/uncloud_pay/serializers.py b/uncloud/uncloud_pay/serializers.py index 16b725a..f5136f6 100644 --- a/uncloud/uncloud_pay/serializers.py +++ b/uncloud/uncloud_pay/serializers.py @@ -34,9 +34,11 @@ class PaymentSerializer(serializers.ModelSerializer): fields = ['owner', 'amount', 'source', 'timestamp'] class PaymentMethodSerializer(serializers.ModelSerializer): + stripe_card_last4 = serializers.IntegerField() + class Meta: model = PaymentMethod - fields = ['source', 'description', 'primary'] + fields = ['source', 'description', 'primary', 'stripe_card_last4'] class CreditCardSerializer(serializers.Serializer): number = serializers.IntegerField() @@ -51,41 +53,6 @@ class CreatePaymentMethodSerializer(serializers.ModelSerializer): model = PaymentMethod fields = ['source', 'description', 'primary', 'credit_card'] - def create(self, validated_data): - credit_card = stripe.CreditCard(**validated_data.pop('credit_card')) - user = self.context['request'].user - customer = stripe.create_customer(user.username, user.email) - # TODO check customer error - customer_id = customer['response_object']['id'] - stripe_card = stripe.create_card(customer_id, credit_card) - # TODO: check credit card error - validated_data['stripe_card_id'] = stripe_card['response_object']['id'] -class CreditCardSerializer(serializers.Serializer): - number = serializers.IntegerField() - exp_month = serializers.IntegerField() - exp_year = serializers.IntegerField() - cvc = serializers.IntegerField() - -class CreatePaymentMethodSerializer(serializers.ModelSerializer): - credit_card = CreditCardSerializer() - - class Meta: - model = PaymentMethod - fields = ['source', 'description', 'primary', 'credit_card'] - - def create(self, validated_data): - credit_card = stripe.CreditCard(**validated_data.pop('credit_card')) - user = self.context['request'].user - customer = stripe.create_customer(user.username, user.email) - # TODO check customer error - customer_id = customer['response_object']['id'] - stripe_card = stripe.create_card(customer_id, credit_card) - # TODO: check credit card error - validated_data['stripe_card_id'] = stripe_card['response_object']['id'] - payment_method = PaymentMethod.objects.create(**validated_data) - return payment_method - payment_method = PaymentMethod.objects.create(**validated_data) - return payment_method ### # Bills diff --git a/uncloud/uncloud_pay/stripe.py b/uncloud/uncloud_pay/stripe.py index c50317f..ab2d865 100644 --- a/uncloud/uncloud_pay/stripe.py +++ b/uncloud/uncloud_pay/stripe.py @@ -2,6 +2,9 @@ import stripe import stripe.error import logging +from django.core.exceptions import ObjectDoesNotExist +import uncloud_pay.models + import uncloud.secrets # Static stripe configuration used below. @@ -79,11 +82,24 @@ class CreditCard(): # Actual Stripe logic. +def get_customer_id_for(user): + try: + # .get() raise if there is no matching entry. + return uncloud_pay.models.StripeCustomer.objects.get(owner=user).stripe_id + except ObjectDoesNotExist: + # No entry yet - making a new one. + customer_request = create_customer(user.username, user.email) + if customer_request['error'] == None: + mapping = uncloud_pay.models.StripeCustomer.objects.create( + owner=user, + stripe_id=customer_request['response_object']['id'] + ) + return mapping.stripe_id + else: + return None + @handle_stripe_error def create_card(customer_id, credit_card): - # Test settings - credit_card.number = "5555555555554444" - return stripe.Customer.create_source( customer_id, card={ @@ -95,7 +111,7 @@ def create_card(customer_id, credit_card): @handle_stripe_error def get_card(customer_id, card_id): - return stripe.Card.retrieve_source(customer_id, card_id) + return stripe.Customer.retrieve_source(customer_id, card_id) @handle_stripe_error def charge_customer(amount, source): diff --git a/uncloud/uncloud_pay/views.py b/uncloud/uncloud_pay/views.py index 936d4c7..294b518 100644 --- a/uncloud/uncloud_pay/views.py +++ b/uncloud/uncloud_pay/views.py @@ -1,4 +1,5 @@ from django.shortcuts import render +from django.db import transaction from django.contrib.auth import get_user_model from rest_framework import viewsets, permissions, status from rest_framework.response import Response @@ -69,13 +70,34 @@ class PaymentMethodViewSet(viewsets.ModelViewSet): def get_queryset(self): return PaymentMethod.objects.filter(owner=self.request.user) + # XXX: Handling of errors is far from great down there. + @transaction.atomic def create(self, request): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) - serializer.save(owner=request.user) - headers = self.get_success_headers(serializer.data) - return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers) + # Retrieve Stripe customer ID for user. + customer_id = stripe.get_customer_id_for(request.user) + if customer_id == None: + return Response( + {'error': 'Could not resolve customer stripe ID.'}, + status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + # Register card under stripe customer. + credit_card = stripe.CreditCard(**serializer.validated_data.pop('credit_card')) + card_request = stripe.create_card(customer_id, credit_card) + if card_request['error']: + return Response({'stripe_error': card_request['error']}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + card_id = card_request['response_object']['id'] + + # Save payment method locally. + serializer.validated_data['stripe_card_id'] = card_request['response_object']['id'] + payment_method = PaymentMethod.objects.create(owner=request.user, **serializer.validated_data) + + # We do not want to return the credit card details sent with the POST + # request. + output_serializer = PaymentMethodSerializer(payment_method) + return Response(output_serializer.data) # TODO: find a way to customize serializer for actions. # drf-action-serializer module seems to do that. From e0cb6ac670d674a45023041d0ba615a70997774d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Tue, 3 Mar 2020 18:16:25 +0100 Subject: [PATCH 08/11] Allow for charging customers --- uncloud/uncloud_pay/models.py | 17 ++++++++++------- uncloud/uncloud_pay/serializers.py | 5 ++++- uncloud/uncloud_pay/stripe.py | 14 +++++++++----- uncloud/uncloud_pay/views.py | 16 +++++++++------- 4 files changed, 32 insertions(+), 20 deletions(-) diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index fa775fc..772ab38 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -86,16 +86,19 @@ class PaymentMethod(models.Model): def charge(self, amount): if amount > 0: # Make sure we don't charge negative amount by errors... if self.source == 'stripe': - # TODO: wire to stripe, see meooow-payv1/strip_utils.py - payment = Payment(owner=self.owner, source=self.source, amount=amount) - payment.save() # TODO: Check return status + stripe_customer = StripeCustomer.objects.get(owner=self.owner).stripe_id + charge_request = uncloud_pay.stripe.charge_customer(amount, stripe_customer, self.stripe_card_id) + if charge_request['error'] == None: + payment = Payment(owner=self.owner, source=self.source, amount=amount) + payment.save() # TODO: Check return status - return True + return payment + else: + raise Exception('Stripe error: {}'.format(charge_request['error'])) else: - # We do not handle that source yet. - return False + raise Exception('This payment method is unsupported/cannot be charged.') else: - return False + raise Exception('Cannot charge negative amount.') class Meta: unique_together = [['owner', 'primary']] diff --git a/uncloud/uncloud_pay/serializers.py b/uncloud/uncloud_pay/serializers.py index f5136f6..94c9b61 100644 --- a/uncloud/uncloud_pay/serializers.py +++ b/uncloud/uncloud_pay/serializers.py @@ -38,7 +38,10 @@ class PaymentMethodSerializer(serializers.ModelSerializer): class Meta: model = PaymentMethod - fields = ['source', 'description', 'primary', 'stripe_card_last4'] + fields = ['uuid', 'source', 'description', 'primary', 'stripe_card_last4'] + +class ChargePaymentMethodSerializer(serializers.Serializer): + amount = serializers.DecimalField(max_digits=10, decimal_places=2) class CreditCardSerializer(serializers.Serializer): number = serializers.IntegerField() diff --git a/uncloud/uncloud_pay/stripe.py b/uncloud/uncloud_pay/stripe.py index ab2d865..4f28d94 100644 --- a/uncloud/uncloud_pay/stripe.py +++ b/uncloud/uncloud_pay/stripe.py @@ -21,7 +21,7 @@ def handle_stripe_error(f): 'error': None } - common_message = "Currently it's not possible to make payments." + common_message = "Currently it is not possible to make payments." try: response_object = f(*args, **kwargs) response = { @@ -114,11 +114,15 @@ def get_card(customer_id, card_id): return stripe.Customer.retrieve_source(customer_id, card_id) @handle_stripe_error -def charge_customer(amount, source): +def charge_customer(amount, customer_id, card_id): + # Amount is in CHF but stripes requires smallest possible unit. + # See https://stripe.com/docs/api/charges/create + adjusted_amount = int(amount * 100) return stripe.Charge.create( - amount=amount, - currenty=CURRENCY, - source=source) + amount=adjusted_amount, + currency=CURRENCY, + customer=customer_id, + source=card_id) @handle_stripe_error def create_customer(name, email): diff --git a/uncloud/uncloud_pay/views.py b/uncloud/uncloud_pay/views.py index 294b518..a6066b4 100644 --- a/uncloud/uncloud_pay/views.py +++ b/uncloud/uncloud_pay/views.py @@ -63,6 +63,8 @@ class PaymentMethodViewSet(viewsets.ModelViewSet): def get_serializer_class(self): if self.action == 'create': return CreatePaymentMethodSerializer + elif self.action == 'charge': + return ChargePaymentMethodSerializer else: return PaymentMethodSerializer @@ -99,18 +101,18 @@ class PaymentMethodViewSet(viewsets.ModelViewSet): output_serializer = PaymentMethodSerializer(payment_method) return Response(output_serializer.data) - # TODO: find a way to customize serializer for actions. - # drf-action-serializer module seems to do that. @action(detail=True, methods=['post']) def charge(self, request, pk=None): payment_method = self.get_object() serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) - amount = serializer.data['amount'] - if payment_method.charge(amount): - return Response({'charged', amount}) - else: - return Response(status=status.HTTP_500_INTERNAL_ERROR) + amount = serializer.validated_data['amount'] + try: + payment = payment_method.charge(amount) + output_serializer = PaymentSerializer(payment) + return Response(output_serializer.data) + except Exception as e: + return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) ### # Admin views. From 9aabc66e574c04d11c27383af34528ea5b853103 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Wed, 4 Mar 2020 09:39:18 +0100 Subject: [PATCH 09/11] Pay: move some model-related methods from helpers to models Otherwise we end up in circular dependency hell --- uncloud/uncloud_pay/helpers.py | 70 ---------- .../commands/charge-negative-balance.py | 5 +- .../management/commands/generate-bills.py | 4 +- .../commands/handle-overdue-bills.py | 3 +- uncloud/uncloud_pay/models.py | 121 +++++++++++++++--- uncloud/uncloud_pay/serializers.py | 12 -- 6 files changed, 108 insertions(+), 107 deletions(-) diff --git a/uncloud/uncloud_pay/helpers.py b/uncloud/uncloud_pay/helpers.py index b4216f6..d02b916 100644 --- a/uncloud/uncloud_pay/helpers.py +++ b/uncloud/uncloud_pay/helpers.py @@ -2,32 +2,9 @@ from functools import reduce from datetime import datetime from rest_framework import mixins from rest_framework.viewsets import GenericViewSet -from django.db.models import Q -from .models import Bill, Payment, PaymentMethod, Order from django.utils import timezone -from django.core.exceptions import ObjectDoesNotExist from calendar import monthrange -def get_balance_for(user): - bills = reduce( - lambda acc, entry: acc + entry.total, - Bill.objects.filter(owner=user), - 0) - payments = reduce( - lambda acc, entry: acc + entry.amount, - Payment.objects.filter(owner=user), - 0) - return payments - bills - -def get_payment_method_for(user): - methods = PaymentMethod.objects.filter(owner=user) - for method in methods: - # Do we want to do something with non-primary method? - if method.primary: - return method - - return None - def beginning_of_month(year, month): tz = timezone.get_current_timezone() return datetime(year=year, month=month, day=1, tzinfo=tz) @@ -38,53 +15,6 @@ def end_of_month(year, month): return datetime(year=year, month=month, day=days, hour=23, minute=59, second=59, tzinfo=tz) -def generate_bills_for(year, month, user, allowed_delay): - # /!\ We exclusively work on the specified year and month. - - # Default values for next bill (if any). Only saved at the end of - # this method, if relevant. - next_bill = Bill(owner=user, - starting_date=beginning_of_month(year, month), - ending_date=end_of_month(year, month), - creation_date=timezone.now(), - due_date=timezone.now() + allowed_delay) - - # Select all orders active on the request period. - orders = Order.objects.filter( - Q(ending_date__gt=next_bill.starting_date) | Q(ending_date__isnull=True), - owner=user) - - # Check if there is already a bill covering the order and period pair: - # * Get latest bill by ending_date: previous_bill.ending_date - # * If previous_bill.ending_date is before next_bill.ending_date, a new - # bill has to be generated. - unpaid_orders = [] - for order in orders: - try: - previous_bill = order.bill.latest('ending_date') - except ObjectDoesNotExist: - previous_bill = None - - if previous_bill == None or previous_bill.ending_date < next_bill.ending_date: - unpaid_orders.append(order) - - # Commit next_bill if it there are 'unpaid' orders. - if len(unpaid_orders) > 0: - next_bill.save() - - # It is not possible to register many-to-many relationship before - # the two end-objects are saved in database. - for order in unpaid_orders: - order.bill.add(next_bill) - - # TODO: use logger. - print("Generated bill {} (amount: {}) for user {}." - .format(next_bill.uuid, next_bill.total, user)) - - return next_bill - - # Return None if no bill was created. - class ProductViewSet(mixins.CreateModelMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, diff --git a/uncloud/uncloud_pay/management/commands/charge-negative-balance.py b/uncloud/uncloud_pay/management/commands/charge-negative-balance.py index 3667a03..24d53bf 100644 --- a/uncloud/uncloud_pay/management/commands/charge-negative-balance.py +++ b/uncloud/uncloud_pay/management/commands/charge-negative-balance.py @@ -1,7 +1,6 @@ from django.core.management.base import BaseCommand from uncloud_auth.models import User -from uncloud_pay.models import Order, Bill -from uncloud_pay.helpers import get_balance_for, get_payment_method_for +from uncloud_pay.models import Order, Bill, PaymentMethod, get_balance_for from datetime import timedelta from django.utils import timezone @@ -19,7 +18,7 @@ class Command(BaseCommand): balance = get_balance_for(user) if balance < 0: print("User {} has negative balance ({}), charging.".format(user.username, balance)) - payment_method = get_payment_method_for(user) + payment_method = PaymentMethod.get_primary_for(user) if payment_method != None: amount_to_be_charged = abs(balance) charge_ok = payment_method.charge(amount_to_be_charged) diff --git a/uncloud/uncloud_pay/management/commands/generate-bills.py b/uncloud/uncloud_pay/management/commands/generate-bills.py index 34432d5..a7dbe78 100644 --- a/uncloud/uncloud_pay/management/commands/generate-bills.py +++ b/uncloud/uncloud_pay/management/commands/generate-bills.py @@ -7,7 +7,7 @@ from django.core.exceptions import ObjectDoesNotExist from datetime import timedelta, date from django.utils import timezone -from uncloud_pay.helpers import generate_bills_for +from uncloud_pay.models import Bill BILL_PAYMENT_DELAY=timedelta(days=10) @@ -28,7 +28,7 @@ class Command(BaseCommand): for user in users: now = timezone.now() - generate_bills_for( + Bill.generate_for( year=now.year, month=now.month, user=user, diff --git a/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py b/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py index f4749f0..40468ba 100644 --- a/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py +++ b/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py @@ -1,7 +1,6 @@ from django.core.management.base import BaseCommand from uncloud_auth.models import User -from uncloud_pay.models import Order, Bill -from uncloud_pay.helpers import get_balance_for, get_payment_method_for +from uncloud_pay.models import Order, Bill, get_balance_for from datetime import timedelta from django.utils import timezone diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 772ab38..6f18931 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -1,17 +1,23 @@ from django.db import models -from functools import reduce +from django.db.models import Q from django.contrib.auth import get_user_model from django.core.validators import MinValueValidator from django.utils.translation import gettext_lazy as _ from django.utils import timezone +from django.dispatch import receiver +from django.core.exceptions import ObjectDoesNotExist +import django.db.models.signals as signals + +import uuid +from functools import reduce from math import ceil from datetime import timedelta from calendar import monthrange + import uncloud_pay.stripe +from uncloud_pay.helpers import beginning_of_month, end_of_month from decimal import Decimal -import uuid - # Define DecimalField properties, used to represent amounts of money. AMOUNT_MAX_DIGITS=10 AMOUNT_DECIMALS=2 @@ -26,6 +32,34 @@ class RecurringPeriod(models.TextChoices): PER_HOUR = 'HOUR', _('Per Hour') PER_SECOND = 'SECOND', _('Per Second') +# See https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices-enum-types +class ProductStatus(models.TextChoices): + PENDING = 'PENDING', _('Pending') + AWAITING_PAYMENT = 'AWAITING_PAYMENT', _('Awaiting payment') + BEING_CREATED = 'BEING_CREATED', _('Being created') + ACTIVE = 'ACTIVE', _('Active') + DELETED = 'DELETED', _('Deleted') + +### +# Users. + +def get_balance_for(user): + bills = reduce( + lambda acc, entry: acc + entry.total, + Bill.objects.filter(owner=user), + 0) + payments = reduce( + lambda acc, entry: acc + entry.amount, + Payment.objects.filter(owner=user), + 0) + return payments - bills + +class StripeCustomer(models.Model): + owner = models.OneToOneField( get_user_model(), + primary_key=True, + on_delete=models.CASCADE) + stripe_id = models.CharField(max_length=32) + ### # Payments and Payment Methods. @@ -100,15 +134,19 @@ class PaymentMethod(models.Model): else: raise Exception('Cannot charge negative amount.') + + def get_primary_for(user): + methods = PaymentMethod.objects.filter(owner=user) + for method in methods: + # Do we want to do something with non-primary method? + if method.primary: + return method + + return None + class Meta: unique_together = [['owner', 'primary']] -class StripeCustomer(models.Model): - owner = models.OneToOneField( get_user_model(), - primary_key=True, - on_delete=models.CASCADE) - stripe_id = models.CharField(max_length=32) - ### # Bills & Payments. @@ -144,6 +182,55 @@ class Bill(models.Model): # A bill is final when its ending date is passed. return self.ending_date < timezone.now() + @staticmethod + def generate_for(year, month, user, allowed_delay): + # /!\ We exclusively work on the specified year and month. + + # Default values for next bill (if any). Only saved at the end of + # this method, if relevant. + next_bill = Bill(owner=user, + starting_date=beginning_of_month(year, month), + ending_date=end_of_month(year, month), + creation_date=timezone.now(), + due_date=timezone.now() + allowed_delay) + + # Select all orders active on the request period. + orders = Order.objects.filter( + Q(ending_date__gt=next_bill.starting_date) | Q(ending_date__isnull=True), + owner=user) + + # Check if there is already a bill covering the order and period pair: + # * Get latest bill by ending_date: previous_bill.ending_date + # * If previous_bill.ending_date is before next_bill.ending_date, a new + # bill has to be generated. + unpaid_orders = [] + for order in orders: + try: + previous_bill = order.bill.latest('ending_date') + except ObjectDoesNotExist: + previous_bill = None + + if previous_bill == None or previous_bill.ending_date < next_bill.ending_date: + unpaid_orders.append(order) + + # Commit next_bill if it there are 'unpaid' orders. + if len(unpaid_orders) > 0: + next_bill.save() + + # It is not possible to register many-to-many relationship before + # the two end-objects are saved in database. + for order in unpaid_orders: + order.bill.add(next_bill) + + # TODO: use logger. + print("Generated bill {} (amount: {}) for user {}." + .format(next_bill.uuid, next_bill.total, user)) + + return next_bill + + # Return None if no bill was created. + return None + class BillRecord(): """ Entry of a bill, dynamically generated from order records. @@ -258,6 +345,10 @@ class Order(models.Model): recurring_price=recurring_price, description=description) + def generate_bill(self): + pass + + class OrderRecord(models.Model): """ Order records store billing informations for products: the actual product @@ -305,15 +396,9 @@ class Product(models.Model): description = "" - status = models.CharField(max_length=256, - choices = ( - ('pending', 'Pending'), - ('being_created', 'Being created'), - ('active', 'Active'), - ('deleted', 'Deleted') - ), - default='pending' - ) + status = models.CharField(max_length=32, + choices=ProductStatus.choices, + default=ProductStatus.AWAITING_PAYMENT) order = models.ForeignKey(Order, on_delete=models.CASCADE, diff --git a/uncloud/uncloud_pay/serializers.py b/uncloud/uncloud_pay/serializers.py index 94c9b61..aa75fd9 100644 --- a/uncloud/uncloud_pay/serializers.py +++ b/uncloud/uncloud_pay/serializers.py @@ -1,13 +1,6 @@ from django.contrib.auth import get_user_model from rest_framework import serializers from .models import * -from .helpers import get_balance_for - -from functools import reduce -from uncloud_vm.serializers import VMProductSerializer -from uncloud_vm.models import VMProduct - -import uncloud_pay.stripe as stripe ### # Users. @@ -19,8 +12,6 @@ class UserSerializer(serializers.ModelSerializer): # Display current 'balance' balance = serializers.SerializerMethodField('get_balance') - def __sum_balance(self, entries): - return reduce(lambda acc, entry: acc + entry.amount, entries, 0) def get_balance(self, user): return get_balance_for(user) @@ -92,6 +83,3 @@ class OrderSerializer(serializers.ModelSerializer): model = Order fields = ['uuid', 'creation_date', 'starting_date', 'ending_date', 'bill', 'recurring_period', 'records', 'recurring_price', 'one_time_price'] - -class ProductSerializer(serializers.Serializer): - vms = VMProductSerializer(many=True, read_only=True) From 9e8149135bdad0b53beff72d74d4a74271ed4140 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Wed, 4 Mar 2020 10:55:12 +0100 Subject: [PATCH 10/11] Move bill generation logic to Bill class, initial work for prepaid --- .../commands/handle-overdue-bills.py | 31 ++-------- uncloud/uncloud_pay/models.py | 56 +++++++++++++++++-- 2 files changed, 56 insertions(+), 31 deletions(-) diff --git a/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py b/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py index 40468ba..595fbc2 100644 --- a/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py +++ b/uncloud/uncloud_pay/management/commands/handle-overdue-bills.py @@ -1,12 +1,12 @@ from django.core.management.base import BaseCommand from uncloud_auth.models import User -from uncloud_pay.models import Order, Bill, get_balance_for +from uncloud_pay.models import Bill from datetime import timedelta from django.utils import timezone class Command(BaseCommand): - help = 'Generate bills and charge customers if necessary.' + help = 'Take action on overdue bills.' def add_arguments(self, parser): pass @@ -15,28 +15,9 @@ class Command(BaseCommand): users = User.objects.all() print("Processing {} users.".format(users.count())) for user in users: - balance = get_balance_for(user) - if balance < 0: - print("User {} has negative balance ({}), checking for overdue bills." - .format(user.username, balance)) - - # Get bills DESCENDING by creation date (= latest at top). - bills = Bill.objects.filter( - owner=user, - due_date__lt=timezone.now() - ).order_by('-creation_date') - overdue_balance = abs(balance) - overdue_bills = [] - for bill in bills: - if overdue_balance < 0: - break # XXX: I'm (fnux) not fond of breaks! - - overdue_balance -= bill.amount - overdue_bills.append(bill) - - for bill in overdue_bills: - print("/!\ Overdue bill for {}, {} with amount {}" - .format(user.username, bill.uuid, bill.amount)) - # TODO: take action? + for bill in Bill.get_overdue_for(user): + print("/!\ Overdue bill for {}, {} with amount {}" + .format(user.username, bill.uuid, bill.amount)) + # TODO: take action? print("=> Done.") diff --git a/uncloud/uncloud_pay/models.py b/uncloud/uncloud_pay/models.py index 6f18931..43064e4 100644 --- a/uncloud/uncloud_pay/models.py +++ b/uncloud/uncloud_pay/models.py @@ -18,10 +18,14 @@ import uncloud_pay.stripe from uncloud_pay.helpers import beginning_of_month, end_of_month from decimal import Decimal + # Define DecimalField properties, used to represent amounts of money. AMOUNT_MAX_DIGITS=10 AMOUNT_DECIMALS=2 +# Used to generate bill due dates. +BILL_PAYMENT_DELAY=timedelta(days=10) + # See https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices-enum-types class RecurringPeriod(models.TextChoices): ONE_TIME = 'ONCE', _('Onetime') @@ -86,6 +90,20 @@ class Payment(models.Model): default='unknown') timestamp = models.DateTimeField(editable=False, auto_now_add=True) + # WIP prepaid and service activation logic by fnux. + ## We override save() in order to active products awaiting payment. + #def save(self, *args, **kwargs): + # # TODO: only run activation logic on creation, not on update. + # unpaid_bills_before_payment = Bill.get_unpaid_for(self.owner) + # super(Payment, self).save(*args, **kwargs) # Save payment in DB. + # unpaid_bills_after_payment = Bill.get_unpaid_for(self.owner) + + # newly_paid_bills = list( + # set(unpaid_bills_before_payment) - set(unpaid_bills_after_payment)) + # for bill in newly_paid_bills: + # bill.activate_orders() + + class PaymentMethod(models.Model): uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) owner = models.ForeignKey(get_user_model(), @@ -183,7 +201,7 @@ class Bill(models.Model): return self.ending_date < timezone.now() @staticmethod - def generate_for(year, month, user, allowed_delay): + def generate_for(year, month, user): # /!\ We exclusively work on the specified year and month. # Default values for next bill (if any). Only saved at the end of @@ -192,7 +210,7 @@ class Bill(models.Model): starting_date=beginning_of_month(year, month), ending_date=end_of_month(year, month), creation_date=timezone.now(), - due_date=timezone.now() + allowed_delay) + due_date=timezone.now() + BILL_PAYMENT_DELAY) # Select all orders active on the request period. orders = Order.objects.filter( @@ -231,6 +249,35 @@ class Bill(models.Model): # Return None if no bill was created. return None + @staticmethod + def get_unpaid_for(user): + balance = get_balance_for(user) + unpaid_bills = [] + # No unpaid bill if balance is positive. + if balance >= 0: + return [] + else: + bills = Bill.objects.filter( + owner=user, + due_date__lt=timezone.now() + ).order_by('-creation_date') + + # Amount to be paid by the customer. + unpaid_balance = abs(balance) + for bill in bills: + if unpaid_balance < 0: + break + + unpaid_balance -= bill.amount + unpaid_bills.append(bill) + + return unpaid_bills + + @staticmethod + def get_overdue_for(user): + unpaid_bills = Bill.get_unpaid_for(user) + return list(filter(lambda bill: bill.due_date > timezone.now(), unpaid_bills)) + class BillRecord(): """ Entry of a bill, dynamically generated from order records. @@ -345,9 +392,6 @@ class Order(models.Model): recurring_price=recurring_price, description=description) - def generate_bill(self): - pass - class OrderRecord(models.Model): """ @@ -398,7 +442,7 @@ class Product(models.Model): status = models.CharField(max_length=32, choices=ProductStatus.choices, - default=ProductStatus.AWAITING_PAYMENT) + default=ProductStatus.PENDING) order = models.ForeignKey(Order, on_delete=models.CASCADE, From faca104459955d4c138274ce3bee4d9268516a26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Floure?= Date: Wed, 4 Mar 2020 11:05:21 +0100 Subject: [PATCH 11/11] Fix stripe import in uncloud_pay.models --- uncloud/uncloud_pay/views.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/uncloud/uncloud_pay/views.py b/uncloud/uncloud_pay/views.py index a6066b4..38d1aa4 100644 --- a/uncloud/uncloud_pay/views.py +++ b/uncloud/uncloud_pay/views.py @@ -10,6 +10,7 @@ import json from .models import * from .serializers import * from datetime import datetime +import uncloud_pay.stripe as uncloud_stripe ### # Standard user views: @@ -79,15 +80,15 @@ class PaymentMethodViewSet(viewsets.ModelViewSet): serializer.is_valid(raise_exception=True) # Retrieve Stripe customer ID for user. - customer_id = stripe.get_customer_id_for(request.user) + customer_id = uncloud_stripe.get_customer_id_for(request.user) if customer_id == None: return Response( {'error': 'Could not resolve customer stripe ID.'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) # Register card under stripe customer. - credit_card = stripe.CreditCard(**serializer.validated_data.pop('credit_card')) - card_request = stripe.create_card(customer_id, credit_card) + credit_card = uncloud_stripe.CreditCard(**serializer.validated_data.pop('credit_card')) + card_request = uncloud_stripe.create_card(customer_id, credit_card) if card_request['error']: return Response({'stripe_error': card_request['error']}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) card_id = card_request['response_object']['id']