uncloud-mravi/uncloud/uncloud_pay/models.py

from django.db import models
from functools import reduce
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

import uuid

AMOUNT_MAX_DIGITS=10
AMOUNT_DECIMALS=2

# See https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices-enum-types
class RecurringPeriod(models.TextChoices):
    ONE_TIME   = 'ONCE', _('Onetime')
    PER_YEAR   = 'YEAR', _('Per Year')
    PER_MONTH  = 'MONTH', _('Per Month')
    PER_MINUTE = 'MINUTE', _('Per Minute')
    PER_DAY    = 'DAY', _('Per Day')
    PER_HOUR   = 'HOUR', _('Per Hour')
    PER_SECOND = 'SECOND', _('Per Second')

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)

    @property
    def entries(self):
        # TODO: return list of Bill entries, extract from linked order
        # for each related order
        #   for each product
        #       build BillEntry
        return []

    @property
    def total(self):
        orders = Order.objects.filter(bill=self)
        return reduce(lambda acc, order: acc + order.amount, orders, 0)

class BillEntry():
    start_date = timezone.now()
    end_date = timezone.now()
    recurring_period = RecurringPeriod.PER_MONTH
    recurring_price = 0
    amount = 0
    description = ""


# /!\ 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(),
                              on_delete=models.CASCADE,
                              editable=False)

    creation_date = models.DateTimeField(auto_now_add=True)
    starting_date = models.DateTimeField(auto_now_add=True)
    ending_date = models.DateTimeField(blank=True,
                                       null=True)

    bill = models.ManyToManyField(Bill,
                                  editable=False,
                                  blank=True)

    recurring_period = models.CharField(max_length=32,
                              choices = RecurringPeriod.choices,
                              default = RecurringPeriod.PER_MONTH)

    @property
    def records(self):
        return OrderRecord.objects.filter(order=self)

    @property
    def setup_fee(self):
        return reduce(lambda acc, record: acc + record.setup_fee, 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):
        OrderRecord.objects.create(order=self,
                setup_fee=setup_fee,
                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,
            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()

    @property
    def recurring_period(self):
        return self.order.recurring_period

class PaymentMethod(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)
    source = models.CharField(max_length=256,
            choices = (
                ('stripe', 'Stripe'),
                ('unknown', 'Unknown'),
                ),
            default='stripe')
    description = models.TextField()
    primary = models.BooleanField(default=True)

    def charge(self, amount):
        if amount > 0: # Make sure we don't charge negative amount by errors...
            if self.source == 'stripe':
                # TODO: wire to strip, see meooow-payv1/strip_utils.py
                payment = Payment(owner=self.owner, source=self.source, amount=amount)
                payment.save() # TODO: Check return status

                return True
            else:
                # We do not handle that source yet.
                return False
        else:
            return False

    class Meta:
        unique_together = [['owner', 'primary']]

class Payment(models.Model):
    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

    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)

class Product(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)

    description = ""

    status = models.CharField(max_length=256,
                              choices = (
                                  ('pending', 'Pending'),
                                  ('being_created', 'Being created'),
                                  ('active', 'Active'),
                                  ('deleted', 'Deleted')
                              ),
                              default='pending'
    )

    order = models.ForeignKey(Order,
                              on_delete=models.CASCADE,
                              editable=False,
                              null=True)

    @property
    def recurring_price(self, recurring_period=RecurringPeriod.PER_MONTH):
        pass # To be implemented in child.

    @property
    def setup_fee(self):
        return 0

    class Meta:
        abstract = True