import logging import datetime from math import ceil from calendar import monthrange from decimal import Decimal from django.conf import settings from django.contrib.auth import get_user_model from django.core.validators import MinValueValidator from django.db import models from django.utils.translation import gettext_lazy as _ from django.utils import timezone # Verify whether or not to use them here from django.core.exceptions import ObjectDoesNotExist, ValidationError from uncloud import AMOUNT_DECIMALS, AMOUNT_MAX_DIGITS from uncloud.models import UncloudAddress from .services import * # Used to generate bill due dates. BILL_PAYMENT_DELAY=datetime.timedelta(days=10) # Initialize logger. logger = logging.getLogger(__name__) def default_payment_delay(): return timezone.now() + BILL_PAYMENT_DELAY class Currency(models.TextChoices): """ Possible currencies to be billed """ CHF = 'CHF', _('Swiss Franc') # EUR = 'EUR', _('Euro') # USD = 'USD', _('US Dollar') ### # Stripe class StripeCustomer(models.Model): owner = models.OneToOneField( get_user_model(), primary_key=True, on_delete=models.CASCADE) stripe_id = models.CharField(max_length=32) def __str__(self): return self.owner.username class StripeCreditCard(models.Model): owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE) card_name = models.CharField(null=False, max_length=128, default="My credit card") card_id = models.CharField(null=False, max_length=32) last4 = models.CharField(null=False, max_length=4) brand = models.CharField(null=False, max_length=64) expiry_date = models.DateField(null=False) active = models.BooleanField(default=False) class Meta: constraints = [ models.UniqueConstraint(fields=['owner'], condition=models.Q(active=True), name='one_active_card_per_user') ] def __str__(self): return f"{self.card_name}: {self.brand} {self.last4} ({self.expiry_date})" class Payment(models.Model): owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE) amount = models.DecimalField( 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'), )) timestamp = models.DateTimeField(default=timezone.now) currency = models.CharField(max_length=32, choices=Currency.choices, default=Currency.CHF) external_reference = models.CharField(max_length=256, default="", null=True, blank=True) def __str__(self): return f"{self.amount}{self.currency} from {self.owner} via {self.source} on {self.timestamp}" ### # Payments and Payment Methods. class PaymentMethod(models.Model): """ Not sure if this is still in use """ 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 active(self): if self.source == 'stripe' and self.stripe_payment_method_id != None: return True else: return False def charge(self, amount): if not self.active: raise Exception('This payment method is inactive.') if amount < 0: # Make sure we don't charge negative amount by errors... 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) return payment else: 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? if method.active and method.primary: return method return None class Meta: # 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 # See https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices-enum-types class RecurringPeriodDefaultChoices(models.IntegerChoices): """ This is an old class and being superseeded by the database model below """ 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') # RecurringPeriods class RecurringPeriod(models.Model): """ Available recurring periods. By default seeded from RecurringPeriodChoices """ name = models.CharField(max_length=100, unique=True) duration_seconds = models.IntegerField(unique=True) @classmethod def populate_db_defaults(cls): for (seconds, name) in RecurringPeriodDefaultChoices.choices: obj, created = cls.objects.get_or_create(name=name, defaults={ 'duration_seconds': seconds }) @staticmethod def secs_to_name(secs): name = "" days = 0 hours = 0 if secs > 24*3600: days = secs // (24*3600) secs -= (days*24*3600) if secs > 3600: hours = secs // 3600 secs -= hours*3600 return f"{days} days {hours} hours {secs} seconds" def __str__(self): duration = self.secs_to_name(self.duration_seconds) return f"{self.name} ({duration})" ### # Bills. class BillingAddress(UncloudAddress): owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE) vat_number = models.CharField(max_length=100, default="", blank=True) vat_number_verified = models.BooleanField(default=False) active = models.BooleanField(default=False) class Meta: constraints = [ models.UniqueConstraint(fields=['owner'], condition=models.Q(active=True), name='one_active_billing_address_per_user') ] @classmethod def populate_db_defaults(cls): """ Ensure we have at least one billing address that is associated with the uncloud-admin. This way we are sure that an UncloudProvider can be created. Cannot use get_or_create as that looks for exactly one. """ owner = get_user_model().objects.get(username=settings.UNCLOUD_ADMIN_NAME) billing_address = cls.objects.filter(owner=owner).first() if not billing_address: billing_address = cls.objects.create(owner=owner, organization="uncloud admins", full_name="Uncloud Admin", street="Uncloudstreet. 42", city="Luchsingen", postal_code="8775", country="CH", active=True) def __str__(self): return "{} - {}, {}, {} {}, {}".format( self.owner, self.full_name, self.street, self.postal_code, self.city, self.country) ### # VAT class VATRate(models.Model): starting_date = models.DateField(blank=True, null=True) ending_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 def __str__(self): return f"{self.territory_codes}: {self.starting_date} - {self.ending_date}: {self.rate_type}" ### # Products class Product(models.Model): """ A product is something a user can order. To record the pricing, we create order that define a state in time. A product can have *one* one_time_order and/or *one* recurring_order. If either of them needs to be updated, a new order of the same type will be created and links to the previous order. """ name = models.CharField(max_length=256, unique=True) description = models.CharField(max_length=1024) config = models.JSONField() recurring_periods = models.ManyToManyField(RecurringPeriod, through='ProductToRecurringPeriod') currency = models.CharField(max_length=32, choices=Currency.choices, default=Currency.CHF) @property def default_recurring_period(self): """ Return the default recurring Period """ return self.recurring_periods.get(producttorecurringperiod__is_default=True) @classmethod def populate_db_defaults(cls): recurring_period = RecurringPeriod.objects.get(name="Per 30 days") obj, created = cls.objects.get_or_create(name="Dual Stack Virtual Machine v1", description="A standard virtual machine", currency=Currency.CHF, config={ 'features': { 'cores': { 'min': 1, 'max': 48, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 3 }, 'ram_gb': { 'min': 1, 'max': 256, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 4 }, 'ssd_gb': { 'min': 10, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 0.35 }, 'hdd_gb': { 'min': 0, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 15/1000 }, 'additional_ipv4_address': { 'min': 0, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 8 }, } } ) obj.recurring_periods.add(recurring_period, through_defaults= { 'is_default': True }) obj, created = cls.objects.get_or_create(name="Dual Stack Virtual Machine v2", description="A standard virtual machine", currency=Currency.CHF, config={ 'features': { 'base': { 'min': 1, 'max': 1, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 1 }, 'cores': { 'min': 1, 'max': 48, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 3 }, 'ram_gb': { 'min': 1, 'max': 256, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 4 }, 'ssd_gb': { 'min': 10, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 0.35 }, 'hdd_gb': { 'min': 0, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 15/1000 }, 'additional_ipv4_address': { 'min': 0, 'one_time_price_per_unit': 0, 'recurring_price_per_unit': 9 }, } } ) obj.recurring_periods.add(recurring_period, through_defaults= { 'is_default': True }) obj, created = cls.objects.get_or_create(name="reverse DNS", description="Reverse DNS network", currency=Currency.CHF, config={ 'parameters': [ 'network' ] }) obj.recurring_periods.add(recurring_period, through_defaults= { 'is_default': True }) def __str__(self): return f"{self.name} - {self.description}" @property def recurring_orders(self): return self.orders.order_by('id').exclude(recurring_period=RecurringPeriod.objects.get(name="ONE_TIME")) @property def last_recurring_order(self): return self.recurring_orders.last() @property def one_time_orders(self): return self.orders.order_by('id').filter(recurring_period=RecurringPeriod.objects.get(name="ONE_TIME")) @property def last_one_time_order(self): return self.one_time_orders.last() def create_order(self, when_to_start=None, recurring_period=None): billing_address = BillingAddress.get_address_for(self.owner) if not billing_address: raise ValidationError("Cannot order without a billing address") if not when_to_start: when_to_start = timezone.now() if not recurring_period: recurring_period = self.default_recurring_period # Create one time order if we did not create one already if self.one_time_price > 0 and not self.last_one_time_order: one_time_order = Order.objects.create(owner=self.owner, billing_address=billing_address, starting_date=when_to_start, price=self.one_time_price, recurring_period=RecurringPeriod.objects.get(name="ONE_TIME"), description=str(self)) self.orders.add(one_time_order) else: one_time_order = None if recurring_period != RecurringPeriod.objects.get(name="ONE_TIME"): if one_time_order: recurring_order = Order.objects.create(owner=self.owner, billing_address=billing_address, starting_date=when_to_start, price=self.recurring_price, recurring_period=recurring_period, depends_on=one_time_order, description=str(self)) else: recurring_order = Order.objects.create(owner=self.owner, billing_address=billing_address, starting_date=when_to_start, price=self.recurring_price, recurring_period=recurring_period, description=str(self)) self.orders.add(recurring_order) # FIXME: this could/should be part of Order (?) def create_or_update_recurring_order(self, when_to_start=None, recurring_period=None): if not self.recurring_price: return if not recurring_period: recurring_period = self.default_recurring_period if not when_to_start: when_to_start = timezone.now() if self.last_recurring_order: if self.recurring_price < self.last_recurring_order.price: if when_to_start < self.last_recurring_order.next_cancel_or_downgrade_date: when_to_start = start_after(self.last_recurring_order.next_cancel_or_downgrade_date) when_to_end = end_before(when_to_start) new_order = Order.objects.create(owner=self.owner, billing_address=self.last_recurring_order.billing_address, starting_date=when_to_start, price=self.recurring_price, recurring_period=recurring_period, description=str(self), replaces=self.last_recurring_order) self.last_recurring_order.replace_with(new_order) self.orders.add(new_order) else: self.create_order(when_to_start, recurring_period) @property def is_recurring(self): return self.recurring_price > 0 @property def billing_address(self): return self.order.billing_address 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) """ # FIXME: This logic needs to be phased out / replaced by product specific (?) # proportions. Maybe using the RecurringPeriod table to link the possible discounts/add ups 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") def save(self, *args, **kwargs): # try: # ba = BillingAddress.get_address_for(self.owner) # except BillingAddress.DoesNotExist: # raise ValidationError("User does not have a billing address") # if not ba.active: # raise ValidationError("User does not have an active billing address") # Verify the required JSON fields super().save(*args, **kwargs) ### # Orders. class Order(models.Model): """ Order are assumed IMMUTABLE and used as SOURCE OF TRUST for generating bills. Do **NOT** mutate then! An one time order is "closed" (does not need to be billed anymore) if it has one bill record. Having more than one is a programming error. A recurring order is closed if it has been replaced (replaces__isnull=False) AND the ending_date is set AND it was billed the last time it needed to be billed (how to check the last item?) BOTH are closed, if they are ended/closed AND have been fully charged. Fully charged == fully billed: sum_of_order_usage == sum_of_bill_records """ owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE, editable=True) billing_address = models.ForeignKey(BillingAddress, on_delete=models.CASCADE) description = models.TextField() product = models.ForeignKey(Product, blank=False, null=False, on_delete=models.CASCADE) config = models.JSONField() creation_date = models.DateTimeField(auto_now_add=True) starting_date = models.DateTimeField(default=timezone.now) ending_date = models.DateTimeField(blank=True, null=True) recurring_period = models.ForeignKey(RecurringPeriod, on_delete=models.CASCADE, editable=True) 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)]) currency = models.CharField(max_length=32, choices=Currency.choices, default=Currency.CHF) replaces = models.ForeignKey('self', related_name='replaced_by', on_delete=models.CASCADE, blank=True, null=True) depends_on = models.ForeignKey('self', related_name='parent_of', on_delete=models.CASCADE, blank=True, null=True) should_be_billed = models.BooleanField(default=True) @property def earliest_ending_date(self): """ Recurring orders cannot end before finishing at least one recurring period. One time orders have a recurring period of 0, so this work universally """ return self.starting_date + datetime.timedelta(seconds=self.recurring_period.duration_seconds) def next_cancel_or_downgrade_date(self, until_when=None): """ Return the next proper ending date after n times the recurring_period, where n is an integer that applies for downgrading or cancelling. """ if not until_when: until_when = timezone.now() if until_when < self.starting_date: raise ValidationError("Cannot end before start of start of order") if self.recurring_period.duration_seconds > 0: delta = until_when - self.starting_date num_times = ceil(delta.total_seconds() / self.recurring_period.duration_seconds) next_date = self.starting_date + datetime.timedelta(seconds=num_times * self.recurring_period.duration_seconds) else: next_date = self.starting_date return next_date def get_ending_date_for_bill(self, bill): """ Determine the ending date given a specific bill """ # If the order is quit, charge the final amount / finish (????) # Probably not a good idea -- FIXME :continue until usual if self.ending_date: this_ending_date = self.ending_date else: if self.next_cancel_or_downgrade_date(bill.ending_date) > bill.ending_date: this_ending_date = self.next_cancel_or_downgrade_date(bill.ending_date) else: this_ending_date = bill.ending_date return this_ending_date @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.quantity for br in self.bill_records.all() ]) def count_used(self, when=None): """ 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 """ if self.is_one_time: return 1 if not when: when = timezone.now() # Cannot be used after it ended if self.ending_date and when > self.ending_date: when = self.ending_date return (when - self.starting_date) / self.default_recurring_period @property def all_usage_billed(self, when=None): """ Returns true if this order does not need any further billing ever. In other words: is this order "closed"? """ if self.count_billed == self.count_used(when): return True else: return False @property def is_closed(self): if self.all_usage_billed and self.ending_date: return True else: return False @property def is_recurring(self): return not self.recurring_period == RecurringPeriod.objects.get(name="ONE_TIME") @property def is_one_time(self): return not self.is_recurring def replace_with(self, new_order): new_order.replaces = self self.ending_date = end_before(new_order.starting_date) self.save() def update_order(self, config, starting_date=None): """ Updating an order means creating a new order and reference the previous order """ if not starting_date: starting_date = timezone.now() new_order = self.__class__(owner=self.owner, billing_address=self.billing_address, description=self.description, product=self.product, config=config, starting_date=starting_date, currency=self.currency ) (new_order.one_time_price, new_order.recurring_price, new_order.config) = new_order.calculate_prices_and_config() new_order.replaces = self new_order.save() self.ending_date = end_before(new_order.starting_date) self.save() return new_order def create_bill_record(self, bill): br = None # Note: check for != 0 not > 0, as we allow discounts to be expressed with < 0 if self.one_time_price != 0 and self.billrecord_set.count() == 0: br = BillRecord.objects.create(bill=bill, order=self, starting_date=self.starting_date, ending_date=self.starting_date, is_recurring_record=False) if self.recurring_price != 0: br = BillRecord.objects.filter(bill=bill, order=self, is_recurring_record=True).first() if br: self.update_bill_record_for_recurring_order(br, bill) else: br = self.create_new_bill_record_for_recurring_order(bill) return br def update_bill_record_for_recurring_order(self, bill_record, bill): """ Possibly update a bill record according to the information in the bill """ # If the order has an ending date set, we might need to adjust the bill_record if self.ending_date: if bill_record_for_this_bill.ending_date != self.ending_date: bill_record_for_this_bill.ending_date = self.ending_date else: # recurring, not terminated, should go until at least end of bill if bill_record_for_this_bill.ending_date < bill.ending_date: bill_record_for_this_bill.ending_date = bill.ending_date bill_record_for_this_bill.save() def create_new_bill_record_for_recurring_order(self, bill): """ Create a new bill record """ last_bill_record = BillRecord.objects.filter(order=self, is_recurring_record=True).order_by('id').last() starting_date=self.starting_date if last_bill_record: # We already charged beyond the end of this bill's period if last_bill_record.ending_date >= bill.ending_date: return # This order is terminated or replaced if self.ending_date: # And the last bill record already covered us -> nothing to be done anymore if last_bill_record.ending_date == self.ending_date: return starting_date = start_after(last_bill_record.ending_date) ending_date = self.get_ending_date_for_bill(bill) return BillRecord.objects.create(bill=bill, order=self, starting_date=starting_date, ending_date=ending_date, is_recurring_record=True) def calculate_prices_and_config(self): one_time_price = 0 recurring_price = 0 if self.config: config = self.config if 'features' not in self.config: self.config['features'] = {} else: config = { 'features': {} } # FIXME: adjust prices to the selected recurring_period to the if 'features' in self.product.config: for feature in self.product.config['features']: # Set min to 0 if not specified min_val = self.product.config['features'][feature].get('min', 0) # We might not even have 'features' cannot use .get() on it try: value = self.config['features'][feature] except (KeyError, TypeError): value = self.product.config['features'][feature]['min'] # Set max to current value if not specified max_val = self.product.config['features'][feature].get('max', value) if value < min_val or value > max_val: raise ValidationError(f"Feature '{feature}' must be at least {min_val} and at maximum {max_val}. Value is: {value}") one_time_price += self.product.config['features'][feature]['one_time_price_per_unit'] * value recurring_price += self.product.config['features'][feature]['recurring_price_per_unit'] * value config['features'][feature] = value return (one_time_price, recurring_price, config) def check_parameters(self): if 'parameters' in self.product.config: for parameter in self.product.config['parameters']: if not parameter in self.config['parameters']: raise ValidationError(f"Required parameter '{parameter}' is missing.") def save(self, *args, **kwargs): # Calculate the price of the order when we create it # IMMUTABLE fields -- need to create new order to modify them # However this is not enforced here... if self._state.adding: (self.one_time_price, self.recurring_price, self.config) = self.calculate_prices_and_config() if self.recurring_period_id is None: self.recurring_period = self.product.default_recurring_period try: prod_period = self.product.recurring_periods.get(producttorecurringperiod__recurring_period=self.recurring_period) except ObjectDoesNotExist: raise ValidationError(f"Recurring Period {self.recurring_period} not allowed for product {self.product}") self.check_parameters() if self.ending_date and self.ending_date < self.starting_date: raise ValidationError("End date cannot be before starting date") super().save(*args, **kwargs) def __str__(self): try: conf = " ".join([ f"{key}:{val}" for key,val in self.config['features'].items() if val != 0 ]) except KeyError: conf = "" return f"Order {self.id}: {self.description} {conf}" class Bill(models.Model): """ A bill is a representation of usage at a specific time """ owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE) creation_date = models.DateTimeField(auto_now_add=True) starting_date = models.DateTimeField(default=start_of_this_month) ending_date = models.DateTimeField() due_date = models.DateField(default=default_payment_delay) billing_address = models.ForeignKey(BillingAddress, on_delete=models.CASCADE, editable=True, null=False) # FIXME: editable=True -> is in the admin, but also editable in DRF # Maybe filter fields in the serializer? is_final = models.BooleanField(default=False) class Meta: constraints = [ models.UniqueConstraint(fields=['owner', 'starting_date', 'ending_date' ], name='one_bill_per_month_per_user') ] def close(self): """ Close/finish a bill """ self.is_final = True self.save() @property def sum(self): bill_records = BillRecord.objects.filter(bill=self) return sum([ br.sum for br in bill_records ]) @property def vat_rate(self): """ Handling VAT is a tricky business - thus we only implement the cases that we clearly now and leave it open to fellow developers to implement correct handling for other cases. Case CH: - If the customer is in .ch -> apply standard rate - If the customer is in EU AND private -> apply country specific rate - If the customer is in EU AND business -> do not apply VAT - If the customer is outside EU and outside CH -> do not apply VAT """ provider = UncloudProvider.objects.get() # Assume always VAT inside the country if provider.country == self.billing_address.country: vat_rate = VATRate.objects.get(country=provider.country, when=self.ending_date) elif self.billing_address.country in EU: # FIXME: need to check for validated vat number if self.billing_address.vat_number: return 0 else: return VATRate.objects.get(country=self.biling_address.country, when=self.ending_date) else: # non-EU, non-national return 0 @classmethod def create_bills_for_all_users(cls): """ Create next bill for each user """ for owner in get_user_model().objects.all(): cls.create_next_bills_for_user(owner) @classmethod def create_next_bills_for_user(cls, owner, ending_date=None): """ Create one bill per billing address, as the VAT rates might be different for each address """ bills = [] for billing_address in BillingAddress.objects.filter(owner=owner): bills.append(cls.create_next_bill_for_user_address(billing_address, ending_date)) return bills @classmethod def create_next_bill_for_user_address(cls, billing_address, ending_date=None): """ Create the next bill for a specific billing address of a user """ owner = billing_address.owner all_orders = Order.objects.filter(owner=owner, billing_address=billing_address).order_by('id') bill = cls.get_or_create_bill(billing_address, ending_date=ending_date) for order in all_orders: order.create_bill_record(bill) return bill @classmethod def get_or_create_bill(cls, billing_address, ending_date=None): """ Get / reuse last bill if it is not yet closed Create bill, if there is no bill or if bill is closed. """ last_bill = cls.objects.filter(billing_address=billing_address).order_by('id').last() all_orders = Order.objects.filter(billing_address=billing_address).order_by('id') first_order = all_orders.first() bill = None # Get date & bill from previous bill, if it exists if last_bill: if not last_bill.is_final: bill = last_bill starting_date = last_bill.starting_date ending_date = bill.ending_date else: starting_date = last_bill.ending_date + datetime.timedelta(seconds=1) else: # Might be an idea to make this the start of the month, too if first_order: starting_date = first_order.starting_date else: starting_date = timezone.now() if not ending_date: ending_date = end_of_month(starting_date) if not bill: bill = cls.objects.create( owner=billing_address.owner, starting_date=starting_date, ending_date=ending_date, billing_address=billing_address) return bill def __str__(self): return f"{self.owner}-{self.id}" 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) creation_date = models.DateTimeField(auto_now_add=True) starting_date = models.DateTimeField() ending_date = models.DateTimeField() is_recurring_record = models.BooleanField(blank=False, null=False) @property def quantity(self): """ Determine the quantity by the duration""" if not self.is_recurring_record: return 1 record_delta = self.ending_date - self.starting_date return record_delta.total_seconds()/self.order.recurring_period.duration_seconds @property def sum(self): if self.is_recurring_record: return self.order.recurring_price * Decimal(self.quantity) else: return self.order.one_time_price @property def price(self): if self.is_recurring_record: return self.order.recurring_price else: return self.order.one_time_price def __str__(self): if self.is_recurring_record: bill_line = f"{self.starting_date} - {self.ending_date}: {self.quantity} x {self.order}" else: bill_line = f"{self.starting_date}: {self.order}" return bill_line def save(self, *args, **kwargs): if self.ending_date < self.starting_date: raise ValidationError("End date cannot be before starting date") super().save(*args, **kwargs) class ProductToRecurringPeriod(models.Model): """ Intermediate manytomany mapping class that allows storing the default recurring period for a product """ recurring_period = models.ForeignKey(RecurringPeriod, on_delete=models.CASCADE) product = models.ForeignKey(Product, on_delete=models.CASCADE) is_default = models.BooleanField(default=False) class Meta: constraints = [ models.UniqueConstraint(fields=['product'], condition=models.Q(is_default=True), name='one_default_recurring_period_per_product'), models.UniqueConstraint(fields=['product', 'recurring_period'], name='recurring_period_once_per_product') ] def __str__(self): return f"{self.product} - {self.recurring_period} (default: {self.is_default})" class Membership(models.Model): owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE) starting_date = models.DateField(blank=True, null=True) ending_date = models.DateField(blank=True, null=True) @classmethod def user_has_membership(user, when): """ Return true if user has membership at a point of time, return false if that is not the case """ pass # cls.objects.filter(owner=user, # starting_date)