in the middle of restructering

This commit is contained in:
Nico Schottelius 2020-05-24 13:45:03 +02:00
parent 5d1eaaf0af
commit a3f3ca8cf9
2 changed files with 103 additions and 386 deletions

View file

@ -31,6 +31,11 @@ logger = logging.getLogger(__name__)
# See https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices-enum-types
class RecurringPeriod(models.IntegerChoices):
"""
We don't support months are years, because the vary in length.
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')
@ -40,14 +45,13 @@ class RecurringPeriod(models.IntegerChoices):
PER_SECOND = 1, _('Per Second')
ONE_TIME = 0, _('Onetime')
class CountryField(models.CharField):
def __init__(self, *args, **kwargs):
kwargs.setdefault('choices', COUNTRIES)
kwargs.setdefault('default', 'CH')
kwargs.setdefault('max_length', 2)
super(CountryField, self).__init__(*args, **kwargs)
super().__init__(*args, **kwargs)
def get_internal_type(self):
return "CharField"
@ -246,7 +250,23 @@ class VATRate(models.Model):
logger.debug("Did not find VAT rate for %s, returning 0" % country_code)
return 0
class BillNico(models.Model):
class BillRecord(models.Model):
"""
Entry of a bill, dynamically generated from an order.
"""
bill = models.ForeignKey(Bill, on_delete=models.CASCADE)
# How many times the order has been used in this record
usage_count = models.IntegerField(default=1)
# 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()
class Bill(models.Model):
""" FIXME:
Bill needs to be unique in the triple (owner, year, month)
"""
@ -262,12 +282,20 @@ class BillNico(models.Model):
valid = models.BooleanField(default=True)
@staticmethod
def create_all_bills():
# 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))
@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):
@ -291,359 +319,55 @@ class BillNico(models.Model):
# FIXME: add something to check whether the order should be billed at all - i.e. a marker that
# disables searching -> optimization for later
for order in Order.objects.filter(Q(starting_date__gte=self.starting_date),
Q(starting_date__lte=self.ending_date),
owner=owner):
# 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),
# order.bill.add(this_bill)
pass
# 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,
usage_count=1,
starting_date=order.starting_date,
ending_date=order.starting_date + timedelta(seconds=order.recurring_period))
"""
Find all recurring orders that did not start in this time frame, but need
to be billed in this time frame.
This is:
- order starting time before our starting time
- order start time + (x * (the_period)) is inside our time frame, x must be integer
test cases:
+ 365days:
time_since_last_billed = self.starting_or_ending_date - order.last_bill_date
periods =
[ we could in theory add this as a property to the order: next
"""
# 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 Bill(models.Model):
uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE)
creation_date = models.DateTimeField(auto_now_add=True)
starting_date = models.DateTimeField()
ending_date = models.DateTimeField()
due_date = models.DateField()
valid = models.BooleanField(default=True)
# Trigger product activation if bill paid at creation (from balance).
def save(self, *args, **kwargs):
super(Bill, self).save(*args, **kwargs)
if not self in Bill.get_unpaid_for(self.owner):
self.activate_products()
@property
def reference(self):
return "{}-{}".format(
self.owner.username,
self.creation_date.strftime("%Y-%m-%d-%H%M"))
@property
def records(self):
bill_records = []
orders = Order.objects.filter(bill=self)
for order in orders:
bill_record = BillRecord(self, order)
bill_records.append(bill_record)
return bill_records
@property
def amount(self):
return reduce(lambda acc, record: acc + record.amount, self.records, 0)
@property
def vat_amount(self):
return reduce(lambda acc, record: acc + record.vat_amount, self.records, 0)
@property
def total(self):
return self.amount + self.vat_amount
@property
def final(self):
# A bill is final when its ending date is passed, or when all of its
# orders have been terminated.
every_order_terminated = True
billing_period_is_over = self.ending_date < timezone.now()
for order in self.order_set.all():
every_order_terminated = every_order_terminated and order.is_terminated
return billing_period_is_over or every_order_terminated
def activate_products(self):
for order in self.order_set.all():
# FIXME: using __something might not be a good idea.
for product_class in Product.__subclasses__():
for product in product_class.objects.filter(order=order):
if product.status == UncloudStatus.AWAITING_PAYMENT:
product.status = UncloudStatus.PENDING
product.save()
@property
def billing_address(self):
orders = Order.objects.filter(bill=self)
# The genrate_for method makes sure all the orders of a bill share the
# same billing address. TODO: It would be nice to enforce that somehow...
if orders:
return orders[0].billing_address
else:
return None
# TODO: split this huuuge method!
@staticmethod
def generate_for(year, month, user):
# /!\ We exclusively work on the specified year and month.
generated_bills = []
# Default values for next bill (if any).
starting_date=beginning_of_month(year, month)
ending_date=end_of_month(year, month)
creation_date=timezone.now()
# Select all orders active on the request period (i.e. starting on or after starting_date).
orders = Order.objects.filter(
Q(ending_date__gte=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
# * For monthly bills: if previous_bill.ending_date is before
# (next_bill) ending_date, a new bill has to be generated.
# * For yearly bill: if previous_bill.ending_date is on working
# month, generate new bill.
unpaid_orders = { 'monthly_or_less': [], 'yearly': {} }
for order in orders:
try:
previous_bill = order.bill.latest('ending_date')
except ObjectDoesNotExist:
previous_bill = None
# FIXME: control flow is confusing in this block.
# if order.recurring_period == RecurringPeriod.PER_YEAR:
# # We ignore anything smaller than a day in here.
# next_yearly_bill_start_on = None
# if previous_bill == None:
# next_yearly_bill_start_on = order.starting_date
# elif previous_bill.ending_date <= ending_date:
# next_yearly_bill_start_on = (previous_bill.ending_date + timedelta(days=1))
# # Store for bill generation. One bucket per day of month with a starting bill.
# # bucket is a reference here, no need to reassign.
# if next_yearly_bill_start_on:
# # We want to group orders by date but keep using datetimes.
# next_yearly_bill_start_on = next_yearly_bill_start_on.replace(
# minute=0, hour=0, second=0, microsecond=0)
# bucket = unpaid_orders['yearly'].get(next_yearly_bill_start_on)
# if bucket == None:
# unpaid_orders['yearly'][next_yearly_bill_start_on] = [order]
# else:
# unpaid_orders['yearly'][next_yearly_bill_start_on] = bucket + [order]
# else:
# if previous_bill == None or previous_bill.ending_date < ending_date:
# unpaid_orders['monthly_or_less'].append(order)
# Handle working month's billing.
if len(unpaid_orders['monthly_or_less']) > 0:
# TODO: PREPAID billing is not supported yet.
prepaid_due_date = min(creation_date, starting_date) + BILL_PAYMENT_DELAY
postpaid_due_date = max(creation_date, ending_date) + BILL_PAYMENT_DELAY
# There should not be any bill linked to orders with different
# billing addresses.
per_address_orders = itertools.groupby(
unpaid_orders['monthly_or_less'],
lambda o: o.billing_address)
for addr, bill_orders in per_address_orders:
next_monthly_bill = Bill.objects.create(owner=user,
creation_date=creation_date,
starting_date=starting_date, # FIXME: this is a hack!
ending_date=ending_date,
due_date=postpaid_due_date)
# It is not possible to register many-to-many relationship before
# the two end-objects are saved in database.
for order in bill_orders:
order.bill.add(next_monthly_bill)
logger.info("Generated monthly bill {} (amount: {}) for user {}."
.format(next_monthly_bill.uuid, next_monthly_bill.total, user))
# Add to output.
generated_bills.append(next_monthly_bill)
# Handle yearly bills starting on working month.
if len(unpaid_orders['yearly']) > 0:
# For every starting date, generate new bill.
for next_yearly_bill_start_on in unpaid_orders['yearly']:
# No postpaid for yearly payments.
prepaid_due_date = min(creation_date, next_yearly_bill_start_on) + BILL_PAYMENT_DELAY
# Bump by one year, remove one day.
ending_date = next_yearly_bill_start_on.replace(
year=next_yearly_bill_start_on.year+1) - timedelta(days=1)
# There should not be any bill linked to orders with different
# billing addresses.
per_address_orders = itertools.groupby(
unpaid_orders['yearly'][next_yearly_bill_start_on],
lambda o: o.billing_address)
for addr, bill_orders in per_address_orders:
next_yearly_bill = Bill.objects.create(owner=user,
creation_date=creation_date,
starting_date=next_yearly_bill_start_on,
ending_date=ending_date,
due_date=prepaid_due_date)
# It is not possible to register many-to-many relationship before
# the two end-objects are saved in database.
for order in bill_orders:
order.bill.add(next_yearly_bill)
logger.info("Generated yearly bill {} (amount: {}) for user {}."
.format(next_yearly_bill.uuid, next_yearly_bill.total, user))
# Add to output.
generated_bills.append(next_yearly_bill)
# Return generated (monthly + yearly) bills.
return generated_bills
@staticmethod
def get_unpaid_for(user):
balance = get_balance_for_user(user)
unpaid_bills = []
# No unpaid bill if balance is positive.
if balance >= 0:
return unpaid_bills
else:
bills = Bill.objects.filter(
owner=user,
).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.total
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 an order.
"""
def __init__(self, bill, order):
self.bill = bill
self.order = order
self.recurring_price = order.recurring_price
self.recurring_period = order.recurring_period
self.description = order.description
if self.order.starting_date >= self.bill.starting_date:
self.one_time_price = order.one_time_price
else:
self.one_time_price = 0
# Set decimal context for amount computations.
# XXX: understand why we need +1 here.
decimal.getcontext().prec = AMOUNT_DECIMALS + 1
@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.bill.ending_date:
billed_until = self.order.ending_date
billed_from = self.bill.starting_date
if self.order.starting_date > self.bill.starting_date:
billed_from = self.order.starting_date
if billed_from > billed_until:
# TODO: think about and check edge cases. This should not be
# possible.
raise Exception('Impossible billing delta!')
billed_delta = billed_until - billed_from
# TODO: refactor this thing?
# TODO: weekly
# if self.recurring_period == RecurringPeriod.PER_YEAR:
# # XXX: Should always be one => we do not bill for more than one year.
# # TODO: check billed_delta is ~365 days.
# return 1
# elif self.recurring_period == RecurringPeriod.PER_MONTH:
# days = ceil(billed_delta / timedelta(days=1))
# # Monthly bills always cover one single month.
# if (self.bill.starting_date.year != self.bill.starting_date.year or
# self.bill.starting_date.month != self.bill.ending_date.month):
# raise Exception('Bill {} covers more than one month. Cannot bill PER_MONTH.'.
# format(self.bill.uuid))
# # XXX: minumal length of monthly order is to be enforced somewhere else.
# (_, days_in_month) = monthrange(
# self.bill.starting_date.year,
# self.bill.starting_date.month)
# return round(days / days_in_month, AMOUNT_DECIMALS)
if self.recurring_period == RecurringPeriod.PER_WEEK:
weeks = ceil(billed_delta / timedelta(week=1))
return weeks
elif self.recurring_period == RecurringPeriod.PER_DAY:
days = ceil(billed_delta / timedelta(days=1))
return days
elif self.recurring_period == RecurringPeriod.PER_HOUR:
hours = ceil(billed_delta / timedelta(hours=1))
return hours
elif self.recurring_period == RecurringPeriod.PER_SECOND:
seconds = ceil(billed_delta / timedelta(seconds=1))
return seconds
elif self.recurring_period == RecurringPeriod.ONE_TIME:
return 0
else:
raise Exception('Unsupported recurring period: {}.'.
format(self.order.recurring_period))
@property
def vat_rate(self):
return Decimal(VATRate.get_for_country(self.bill.billing_address.country))
@property
def vat_amount(self):
return self.amount * self.vat_rate
@property
def amount(self):
return Decimal(float(self.recurring_price) * self.recurring_count) + self.one_time_price
@property
def total(self):
return self.amount + self.vat_amount
###
# Orders.
# Order are assumed IMMUTABLE and used as SOURCE OF TRUST for generating
# bills. Do **NOT** mutate then!
class Order(models.Model):
"""
Order are assumed IMMUTABLE and used as SOURCE OF TRUST for generating
bills. Do **NOT** mutate then!
"""
uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE,
@ -658,11 +382,22 @@ class Order(models.Model):
ending_date = models.DateTimeField(blank=True,
null=True)
bill = models.ManyToManyField(Bill,
bill_records = models.ManyToManyField(BillRecord,
editable=False,
blank=True)
recurring_period = models.IntegerField(choices = RecurringPeriod.choices, default = RecurringPeriod.PER_30D)
@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
"""
return sum([ br.usage_count for br in self.bill_records.all() ])
recurring_period = models.IntegerField(choices = RecurringPeriod.choices,
default = RecurringPeriod.PER_30D)
one_time_price = models.DecimalField(default=0.0,
max_digits=AMOUNT_MAX_DIGITS,
@ -696,7 +431,6 @@ class Order(models.Model):
@property
def is_recurring(self):
return not self.recurring_period == RecurringPeriod.ONE_TIME
@property
def is_terminated(self):
return self.ending_date != None and self.ending_date < timezone.now()
@ -709,9 +443,6 @@ class Order(models.Model):
self.ending_date = timezone.now()
self.save()
def is_to_be_charged_in(year, month):
pass
# Trigger initial bill generation at order creation.
def save(self, *args, **kwargs):
if self.ending_date and self.ending_date < self.starting_date:
@ -749,35 +480,6 @@ class Order(models.Model):
self.one_time_price,
self.recurring_price)
class OrderTimothee(models.Model):
uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
owner = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE,
editable=False)
billing_address = models.ForeignKey(BillingAddress, on_delete=models.CASCADE)
# 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)
bill = models.ManyToManyField(Bill,
editable=False,
blank=True)
recurring_period = models.IntegerField(choices = RecurringPeriod.choices,
default = RecurringPeriod.PER_30D)
# 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)
@property
def records(self):
return OrderRecord.objects.filter(order=self)
@ -988,3 +690,16 @@ class Product(UncloudModel):
else:
# FIXME: use the right type of exception here!
raise Exception("Did not implement the discounter for this case")
# 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)

View file

@ -5,7 +5,8 @@ from datetime import datetime, date, timedelta
from .models import *
from uncloud_service.models import GenericServiceProduct
class BillingTestCase(TestCase):
class NotABillingTC(TestCase):
#class BillingTestCase(TestCase):
def setUp(self):
self.user = get_user_model().objects.create(
username='jdoe',
@ -22,15 +23,16 @@ class BillingTestCase(TestCase):
description = "Test Product 1"
# Three months: full, full, partial.
starting_date = datetime.fromisoformat('2020-03-01')
ending_date = datetime.fromisoformat('2020-05-08')
# starting_date = datetime.fromisoformat('2020-03-01')
starting_date = datetime(2020,3,1)
ending_date = datetime(2020,5,8)
# Create order to be billed.
order = Order.objects.create(
owner=self.user,
starting_date=starting_date,
ending_date=ending_date,
recurring_period=RecurringPeriod.PER_MONTH,
recurring_period=RecurringPeriod.PER_30D,
recurring_price=recurring_price,
one_time_price=one_time_price,
description=description,
@ -67,7 +69,7 @@ class BillingTestCase(TestCase):
order = Order.objects.create(
owner=self.user,
starting_date=starting_date,
recurring_period=RecurringPeriod.PER_YEAR,
recurring_period=RecurringPeriod.PER_365D,
recurring_price=recurring_price,
one_time_price=one_time_price,
description=description,
@ -150,7 +152,7 @@ class ProductActivationTestCase(TestCase):
order = Order.objects.create(
owner=self.user,
starting_date=starting_date,
recurring_period=RecurringPeriod.PER_MONTH,
recurring_period=RecurringPeriod.PER_30D,
recurring_price=recurring_price,
one_time_price=one_time_price,
description=description,
@ -205,12 +207,12 @@ class BillingAddressTestCase(TestCase):
order_01 = Order.objects.create(
owner=self.user,
starting_date=starting_date,
recurring_period=RecurringPeriod.PER_MONTH,
recurring_period=RecurringPeriod.PER_30D,
billing_address=self.billing_address_01)
order_02 = Order.objects.create(
owner=self.user,
starting_date=starting_date,
recurring_period=RecurringPeriod.PER_MONTH,
recurring_period=RecurringPeriod.PER_30D,
billing_address=self.billing_address_01)
# We need a single bill since we work with a single address.
@ -225,12 +227,12 @@ class BillingAddressTestCase(TestCase):
order_01 = Order.objects.create(
owner=self.user,
starting_date=starting_date,
recurring_period=RecurringPeriod.PER_MONTH,
recurring_period=RecurringPeriod.PER_30D,
billing_address=self.billing_address_01)
order_02 = Order.objects.create(
owner=self.user,
starting_date=starting_date,
recurring_period=RecurringPeriod.PER_MONTH,
recurring_period=RecurringPeriod.PER_30D,
billing_address=self.billing_address_02)
# We need different bills since we work with different addresses.