uncloud/uncloud_pay/models.py

752 lines
26 KiB
Python
Raw Normal View History

2020-02-27 10:21:38 +00:00
from django.db import models
from django.db.models import Q
2020-02-27 10:21:38 +00:00
from django.contrib.auth import get_user_model
from django.utils.translation import gettext_lazy as _
from django.core.validators import MinValueValidator
2020-02-29 08:08:30 +00:00
from django.utils import timezone
from django.core.exceptions import ObjectDoesNotExist, ValidationError
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
import logging
from functools import reduce
import itertools
from math import ceil
2020-06-21 14:08:00 +00:00
import datetime
from calendar import monthrange
from decimal import Decimal
import uncloud_pay.stripe
from uncloud_pay.helpers import beginning_of_month, end_of_month
from uncloud_pay import AMOUNT_DECIMALS, AMOUNT_MAX_DIGITS, COUNTRIES
2020-03-22 19:55:11 +00:00
from uncloud.models import UncloudModel, UncloudStatus
2020-02-27 10:21:38 +00:00
2020-03-03 10:15:48 +00:00
from decimal import Decimal
import decimal
# Used to generate bill due dates.
2020-06-21 14:08:00 +00:00
BILL_PAYMENT_DELAY=datetime.timedelta(days=10)
# Initialize logger.
logger = logging.getLogger(__name__)
2020-06-21 14:08:00 +00:00
def start_of_month(a_day):
""" Returns first of the month of a given datetime object"""
return a_day.replace(day=1,hour=0,minute=0,second=0, microsecond=0)
def end_of_month(a_day):
""" Returns first of the month of a given datetime object"""
_, last_day = monthrange(a_day.year, a_day.month)
return a_day.replace(day=last_day,hour=23,minute=59,second=59, microsecond=0)
def start_of_this_month():
""" Returns first of this month"""
a_day = timezone.now()
return a_day.replace(day=1,hour=0,minute=0,second=0, microsecond=0)
def end_of_this_month():
""" Returns first of this month"""
a_day = timezone.now()
_, last_day = monthrange(a_day.year, a_day.month)
return a_day.replace(day=last_day,hour=23,minute=59,second=59, microsecond=0)
def default_payment_delay():
return timezone.now() + BILL_PAYMENT_DELAY
# See https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices-enum-types
class RecurringPeriod(models.IntegerChoices):
2020-05-24 11:45:03 +00:00
"""
2020-08-01 14:29:24 +00:00
We don't support months are years, because they vary in length.
2020-05-24 11:45:03 +00:00
This is not only complicated, but also unfair to the user, as the user pays the same
amount for different durations.
"""
PER_365D = 365*24*3600, _('Per 365 days')
PER_30D = 30*24*3600, _('Per 30 days')
PER_WEEK = 7*24*3600, _('Per Week')
PER_DAY = 24*3600, _('Per Day')
PER_HOUR = 3600, _('Per Hour')
PER_MINUTE = 60, _('Per Minute')
PER_SECOND = 1, _('Per Second')
ONE_TIME = 0, _('Onetime')
2020-05-23 21:08:59 +00:00
2020-04-15 13:17:38 +00:00
class CountryField(models.CharField):
def __init__(self, *args, **kwargs):
kwargs.setdefault('choices', COUNTRIES)
kwargs.setdefault('default', 'CH')
kwargs.setdefault('max_length', 2)
2020-05-24 11:45:03 +00:00
super().__init__(*args, **kwargs)
2020-04-15 13:17:38 +00:00
def get_internal_type(self):
return "CharField"
2020-03-18 13:36:40 +00:00
def get_balance_for_user(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.
class Payment(models.Model):
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE)
amount = models.DecimalField(
default=0.0,
max_digits=AMOUNT_MAX_DIGITS,
decimal_places=AMOUNT_DECIMALS,
validators=[MinValueValidator(0)])
source = models.CharField(max_length=256,
choices = (
('wire', 'Wire Transfer'),
('stripe', 'Stripe'),
('voucher', 'Voucher'),
('referral', 'Referral'),
('unknown', 'Unknown')
),
default='unknown')
timestamp = models.DateTimeField(editable=False, auto_now_add=True)
# We override save() in order to active products awaiting payment.
def save(self, *args, **kwargs):
# _state.adding is switched to false after super(...) call.
being_created = self._state.adding
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_products()
2020-05-23 21:08:59 +00:00
class PaymentMethod(models.Model):
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE,
editable=False)
source = models.CharField(max_length=256,
choices = (
('stripe', 'Stripe'),
('unknown', 'Unknown'),
),
default='stripe')
description = models.TextField()
primary = models.BooleanField(default=False, editable=False)
# Only used for "Stripe" source
stripe_payment_method_id = models.CharField(max_length=32, blank=True, null=True)
stripe_setup_intent_id = models.CharField(max_length=32, blank=True, null=True)
@property
def stripe_card_last4(self):
if self.source == 'stripe' and self.active:
payment_method = uncloud_pay.stripe.get_payment_method(
self.stripe_payment_method_id)
return payment_method.card.last4
else:
return None
@property
def active(self):
if self.source == 'stripe' and self.stripe_payment_method_id != None:
return True
else:
return False
def charge(self, amount):
2020-03-05 10:03:47 +00:00
if not self.active:
raise Exception('This payment method is inactive.')
if amount < 0: # Make sure we don't charge negative amount by errors...
2020-03-05 10:03:47 +00:00
raise Exception('Cannot charge negative amount.')
if self.source == 'stripe':
stripe_customer = StripeCustomer.objects.get(owner=self.owner).stripe_id
stripe_payment = uncloud_pay.stripe.charge_customer(
amount, stripe_customer, self.stripe_payment_method_id)
if 'paid' in stripe_payment and stripe_payment['paid'] == False:
raise Exception(stripe_payment['error'])
else:
payment = Payment.objects.create(
owner=self.owner, source=self.source, amount=amount)
2020-03-05 10:03:47 +00:00
return payment
else:
2020-03-05 10:03:47 +00:00
raise Exception('This payment method is unsupported/cannot be charged.')
def set_as_primary_for(self, user):
methods = PaymentMethod.objects.filter(owner=user, primary=True)
for method in methods:
print(method)
method.primary = False
method.save()
self.primary = True
self.save()
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?
2020-03-05 10:03:47 +00:00
if method.active and method.primary:
return method
return None
class Meta:
2020-03-05 10:03:47 +00:00
# TODO: limit to one primary method per user.
# unique_together is no good since it won't allow more than one
# non-primary method.
pass
###
2020-03-05 09:27:33 +00:00
# Bills.
class BillingAddress(models.Model):
owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
2020-05-07 13:38:49 +00:00
organization = models.CharField(max_length=100)
name = models.CharField(max_length=100)
street = models.CharField(max_length=100)
city = models.CharField(max_length=50)
postal_code = models.CharField(max_length=50)
country = CountryField(blank=True)
vat_number = models.CharField(max_length=100, default="", blank=True)
active = models.BooleanField(default=False)
class Meta:
constraints = [
models.UniqueConstraint(fields=['owner'],
2020-06-21 12:45:05 +00:00
condition=Q(active=True),
name='one_active_billing_address_per_user')
]
@staticmethod
def get_addresses_for(user):
return BillingAddress.objects.filter(owner=user)
@classmethod
def get_preferred_address_for(cls, user):
addresses = cls.get_addresses_for(user)
if len(addresses) == 0:
return None
else:
# TODO: allow user to set primary/preferred address
return addresses[0]
def __str__(self):
2020-06-21 11:46:54 +00:00
return "{} - {}, {}, {} {}, {}".format(
self.owner,
self.name, self.street, self.postal_code, self.city,
self.country)
###
# VAT
class VATRate(models.Model):
start_date = models.DateField(blank=True, null=True)
stop_date = models.DateField(blank=True, null=True)
territory_codes = models.TextField(blank=True, default='')
currency_code = models.CharField(max_length=10)
rate = models.FloatField()
rate_type = models.TextField(blank=True, default='')
description = models.TextField(blank=True, default='')
@staticmethod
def get_for_country(country_code):
vat_rate = None
try:
vat_rate = VATRate.objects.get(
territory_codes=country_code, start_date__isnull=False, stop_date=None
)
return vat_rate.rate
except VATRate.DoesNotExist as dne:
logger.debug(str(dne))
logger.debug("Did not find VAT rate for %s, returning 0" % country_code)
return 0
###
# Orders.
2020-02-27 10:21:38 +00:00
class Order(models.Model):
2020-05-24 11:45:03 +00:00
"""
Order are assumed IMMUTABLE and used as SOURCE OF TRUST for generating
bills. Do **NOT** mutate then!
"""
2020-02-27 10:21:38 +00:00
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE,
editable=True)
billing_address = models.ForeignKey(BillingAddress,
on_delete=models.CASCADE)
2020-05-07 10:08:18 +00:00
description = models.TextField()
2020-02-27 10:21:38 +00:00
# TODO: enforce ending_date - starting_date to be larger than recurring_period.
creation_date = models.DateTimeField(auto_now_add=True)
starting_date = models.DateTimeField(default=timezone.now)
ending_date = models.DateTimeField(blank=True, null=True)
2020-05-24 11:45:03 +00:00
recurring_period = models.IntegerField(choices = RecurringPeriod.choices,
default = RecurringPeriod.PER_30D)
one_time_price = models.DecimalField(default=0.0,
max_digits=AMOUNT_MAX_DIGITS,
decimal_places=AMOUNT_DECIMALS,
validators=[MinValueValidator(0)])
recurring_price = models.DecimalField(default=0.0,
max_digits=AMOUNT_MAX_DIGITS,
decimal_places=AMOUNT_DECIMALS,
validators=[MinValueValidator(0)])
replaces = models.ForeignKey('self',
related_name='replaced_by',
on_delete=models.PROTECT,
blank=True,
null=True)
2020-05-08 14:47:32 +00:00
depends_on = models.ForeignKey('self',
related_name='parent_of',
on_delete=models.PROTECT,
blank=True,
null=True)
2020-05-08 14:47:32 +00:00
@property
def count_billed(self):
"""
How many times this order was billed so far.
This logic is mainly thought to be for recurring bills, but also works for one time bills
"""
2020-06-21 14:42:55 +00:00
return sum([ br.quantity for br in self.bill_records.all() ])
2020-05-23 19:32:56 +00:00
def active_before(self, ending_date):
# Was this order started before the specified ending date?
if self.starting_date <= ending_date:
if self.ending_date:
if self.ending_date > ending_date:
2020-05-23 21:08:59 +00:00
pass
2020-05-23 19:32:56 +00:00
@property
def is_recurring(self):
return not self.recurring_period == RecurringPeriod.ONE_TIME
2020-05-08 07:31:46 +00:00
@property
def is_terminated(self):
return self.ending_date != None and self.ending_date < timezone.now()
2020-05-23 19:32:56 +00:00
def is_terminated_at(self, a_date):
return self.ending_date != None and self.ending_date < timezone.now()
2020-05-08 07:31:46 +00:00
def terminate(self):
if not self.is_terminated:
self.ending_date = timezone.now()
self.save()
# Trigger initial bill generation at order creation.
def save(self, *args, **kwargs):
if self.ending_date and self.ending_date < self.starting_date:
raise ValidationError("End date cannot be before starting date")
super().save(*args, **kwargs)
2020-05-08 09:33:59 +00:00
def generate_initial_bill(self):
return Bill.generate_for(self.starting_date.year, self.starting_date.month, self.owner)
2020-05-08 09:33:59 +00:00
# Used by uncloud_pay tests.
@property
def bills(self):
return Bill.objects.filter(order=self)
2020-04-18 11:51:31 +00:00
@staticmethod
def from_product(product, **kwargs):
# FIXME: this is only a workaround.
billing_address = BillingAddress.get_preferred_address_for(product.owner)
if billing_address == None:
raise Exception("Owner does not have a billing address!")
return Order(description=product.description,
one_time_price=product.one_time_price,
recurring_price=product.recurring_price,
billing_address=billing_address,
owner=product.owner,
**kwargs)
2020-03-02 08:25:03 +00:00
@property
def records(self):
return OrderRecord.objects.filter(order=self)
# these are real fields!!!
# @property
# def one_time_price(self):
# return reduce(lambda acc, record: acc + record.one_time_price, self.records, 0)
2020-02-29 08:08:30 +00:00
# @property
# def recurring_price(self):
# return reduce(lambda acc, record: acc + record.recurring_price, self.records, 0)
2020-03-02 08:25:03 +00:00
# Used by uncloud_pay tests.
@property
def bills(self):
return Bill.objects.filter(order=self)
def add_record(self, one_time_price, recurring_price, description):
OrderRecord.objects.create(order=self,
one_time_price=one_time_price,
recurring_price=recurring_price,
description=description)
def __str__(self):
2020-06-21 14:08:00 +00:00
return f"Order {self.owner}-{self.id}"
2020-06-21 14:08:00 +00:00
# return "{} created at {}, {}->{}, recurring period {}. One time price {}, recurring price {}".format(
# self.id, self.creation_date,
# self.starting_date, self.ending_date,
# self.recurring_period,
# self.one_time_price,
# self.recurring_price)
2020-06-21 11:46:54 +00:00
2020-06-21 14:08:00 +00:00
class Bill(models.Model):
2020-06-21 11:46:54 +00:00
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE)
creation_date = models.DateTimeField(auto_now_add=True)
2020-08-01 12:05:50 +00:00
2020-06-21 14:08:00 +00:00
# FIXME: this is a race condition, if ending_date is evaluated
# in the next month the bill spawns two months!
starting_date = models.DateTimeField(default=start_of_this_month)
ending_date = models.DateTimeField(default=end_of_this_month)
due_date = models.DateField(default=default_payment_delay)
2020-06-21 11:46:54 +00:00
valid = models.BooleanField(default=True)
# Mapping to BillRecords
# https://stackoverflow.com/questions/4443190/djangos-manytomany-relationship-with-additional-fields
bill_records = models.ManyToManyField(Order, through="BillRecord")
2020-06-21 14:08:00 +00:00
class Meta:
constraints = [
models.UniqueConstraint(fields=['owner',
'starting_date',
'ending_date' ],
name='one_bill_per_month_per_user')
]
2020-06-21 11:46:54 +00:00
# billing address and vat rate is the same for the whole bill
# @property
# def vat_rate(self):
# return Decimal(VATRate.get_for_country(self.bill.billing_address.country))
def __str__(self):
2020-06-21 14:08:00 +00:00
return f"Bill {self.owner}-{self.id}"
2020-06-21 11:46:54 +00:00
@classmethod
def create_all_bills(cls):
for owner in get_user_model().objects.all():
# mintime = time of first order
# maxtime = time of last order
# iterate month based through it
cls.assign_orders_to_bill(owner, year, month)
pass
def assign_orders_to_bill(self, owner, year, month):
"""
Generate a bill for the specific month of a user.
First handle all one time orders
FIXME:
- limit this to active users in the future! (2020-05-23)
"""
"""
Find all one time orders that have a starting date that falls into this month
recurring_period=RecurringPeriod.ONE_TIME,
Can we do this even for recurring / all of them
"""
# FIXME: add something to check whether the order should be billed at all - i.e. a marker that
# disables searching -> optimization for later
# Create the initial bill record
# FIXME: maybe limit not even to starting/ending date, but to empty_bill record -- to be fixed in the future
# for order in Order.objects.filter(Q(starting_date__gte=self.starting_date),
# Q(starting_date__lte=self.ending_date),
# FIXME below: only check for active orders
# Ensure all orders of that owner have at least one bill record
for order in Order.objects.filter(owner=owner,
bill_records=None):
bill_record = BillRecord.objects.create(bill=self,
2020-06-21 14:42:55 +00:00
quantity=1,
2020-06-21 11:46:54 +00:00
starting_date=order.starting_date,
ending_date=order.starting_date + timedelta(seconds=order.recurring_period))
# For each recurring order get the usage and bill it
for order in Order.objects.filter(~Q(recurring_period=RecurringPeriod.ONE_TIME),
Q(starting_date__lt=self.starting_date),
owner=owner):
if order.recurring_period > 0: # avoid div/0 - these are one time payments
# How much time will have passed by the end of the billing cycle
td = self.ending_date - order.starting_date
# How MANY times it will have been used by then
used_times = ceil(td / timedelta(seconds=order.recurring_period))
billed_times = len(order.bills)
# How many times it WAS billed -- can also be inferred from the bills that link to it!
if used_times > billed_times:
billing_times = used_times - billed_times
# ALSO REGISTER THE TIME PERIOD!
pass
class BillRecord(models.Model):
"""
Entry of a bill, dynamically generated from an order.
"""
bill = models.ForeignKey(Bill, on_delete=models.CASCADE)
order = models.ForeignKey(Order, on_delete=models.CASCADE)
# How many times the order has been used in this record
2020-06-21 14:42:55 +00:00
quantity = models.IntegerField(default=1)
2020-06-21 11:46:54 +00:00
# The timeframe the bill record is for can (and probably often will) differ
# from the bill time
creation_date = models.DateTimeField(auto_now_add=True)
starting_date = models.DateTimeField()
ending_date = models.DateTimeField()
def __str__(self):
2020-06-21 14:42:55 +00:00
return f"{self.bill}: {self.quantity} x {self.order}"
2020-06-21 11:46:54 +00:00
2020-03-02 07:09:42 +00:00
class OrderRecord(models.Model):
2020-03-03 10:34:47 +00:00
"""
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.
"""
2020-03-02 07:09:42 +00:00
order = models.ForeignKey(Order, on_delete=models.CASCADE)
2020-06-21 11:46:54 +00:00
one_time_price = models.DecimalField(default=0.0,
2020-03-02 07:09:42 +00:00
max_digits=AMOUNT_MAX_DIGITS,
decimal_places=AMOUNT_DECIMALS,
validators=[MinValueValidator(0)])
recurring_price = models.DecimalField(default=0.0,
max_digits=AMOUNT_MAX_DIGITS,
decimal_places=AMOUNT_DECIMALS,
validators=[MinValueValidator(0)])
description = models.TextField()
2020-02-27 10:21:38 +00:00
2020-03-21 10:59:04 +00:00
2020-03-02 07:09:42 +00:00
@property
def recurring_period(self):
return self.order.recurring_period
2020-02-27 10:21:38 +00:00
@property
def starting_date(self):
return self.order.starting_date
@property
def ending_date(self):
return self.order.ending_date
2020-02-27 10:21:38 +00:00
###
# Products
# Abstract (= no database representation) class used as parent for products
# (e.g. uncloud_vm.models.VMProduct).
2020-03-21 10:59:04 +00:00
class Product(UncloudModel):
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE,
editable=False)
description = "Generic Product"
status = models.CharField(max_length=32,
2020-03-22 19:55:11 +00:00
choices=UncloudStatus.choices,
default=UncloudStatus.AWAITING_PAYMENT)
order = models.ForeignKey(Order,
on_delete=models.CASCADE,
editable=False,
null=True)
# Default period for all products
default_recurring_period = RecurringPeriod.PER_30D
# Used to save records.
def save(self, *args, **kwargs):
# _state.adding is switched to false after super(...) call.
being_created = self._state.adding
# First time saving - create an order
if not self.order:
billing_address = BillingAddress.get_preferred_address_for(self.owner)
print(billing_address)
if not billing_address:
raise ValidationError("Cannot order without a billing address")
2020-05-07 18:22:42 +00:00
# FIXME: allow user to choose recurring_period
self.order = Order.objects.create(owner=self.owner,
2020-05-02 21:44:20 +00:00
billing_address=billing_address,
one_time_price=self.one_time_price,
2020-05-07 18:22:42 +00:00
recurring_period=self.default_recurring_period,
2020-05-02 21:44:20 +00:00
recurring_price=self.recurring_price)
super().save(*args, **kwargs)
# # Make sure we only create records on creation.
# if being_created:
# record = OrderRecord(
# one_time_price=self.one_time_price,
# recurring_price=self.recurring_price,
# description=self.description)
# self.order.orderrecord_set.add(record, bulk=False)
@property
def recurring_price(self):
pass # To be implemented in child.
@property
def one_time_price(self):
2020-08-01 14:29:24 +00:00
"""
Default is 0 CHF
"""
return 0
@property
def billing_address(self):
return self.order.billing_address
2020-03-03 09:51:16 +00:00
@staticmethod
def allowed_recurring_periods():
return RecurringPeriod.choices
class Meta:
abstract = True
def discounted_price_by_period(self, requested_period):
"""
Each product has a standard recurring period for which
we define a pricing. I.e. VPN is usually year, VM is usually monthly.
The user can opt-in to use a different period, which influences the price:
The longer a user commits, the higher the discount.
Products can also be limited in the available periods. For instance
a VPN only makes sense to be bought for at least one day.
Rules are as follows:
given a standard recurring period of ..., changing to ... modifies price ...
# One month for free if buying / year, compared to a month: about 8.33% discount
per_year -> per_month -> /11
per_month -> per_year -> *11
# Month has 30.42 days on average. About 7.9% discount to go monthly
per_month -> per_day -> /28
per_day -> per_month -> *28
# Day has 24h, give one for free
per_day -> per_hour -> /23
per_hour -> per_day -> /23
Examples
VPN @ 120CHF/y becomes
- 10.91 CHF/month (130.91 CHF/year)
- 0.39 CHF/day (142.21 CHF/year)
VM @ 15 CHF/month becomes
- 165 CHF/month (13.75 CHF/month)
- 0.54 CHF/day (16.30 CHF/month)
"""
if self.default_recurring_period == RecurringPeriod.PER_365D:
if requested_period == RecurringPeriod.PER_365D:
return self.recurring_price
if requested_period == RecurringPeriod.PER_30D:
return self.recurring_price/11.
if requested_period == RecurringPeriod.PER_DAY:
return self.recurring_price/11./28.
elif self.default_recurring_period == RecurringPeriod.PER_30D:
if requested_period == RecurringPeriod.PER_365D:
return self.recurring_price*11
if requested_period == RecurringPeriod.PER_30D:
return self.recurring_price
if requested_period == RecurringPeriod.PER_DAY:
return self.recurring_price/28.
elif self.default_recurring_period == RecurringPeriod.PER_DAY:
if requested_period == RecurringPeriod.PER_365D:
return self.recurring_price*11*28
if requested_period == RecurringPeriod.PER_30D:
return self.recurring_price*28
if requested_period == RecurringPeriod.PER_DAY:
return self.recurring_price
else:
# FIXME: use the right type of exception here!
raise Exception("Did not implement the discounter for this case")
2020-05-24 11:45:03 +00:00
# Interesting snippets
# # Trigger initial bill generation at order creation.
# def save(self, *args, **kwargs):
# if self.ending_date and self.ending_date < self.starting_date:
# raise ValidationError("End date cannot be before starting date")
# super().save(*args, **kwargs)
# Bill.generate_for(self.starting_date.year, self.starting_date.month, self.owner)