coin/coin/billing/models.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import datetime
import uuid
import re
import logging
from decimal import Decimal

from django.db import models, transaction
from django.utils.encoding import python_2_unicode_compatible

from coin.offers.models import OfferSubscription
from coin.members.models import Member
from coin.html2pdf import render_as_pdf
from coin.utils import private_files_storage, start_of_month, end_of_month, \
                       postgresql_regexp
from coin.isp_database.context_processors import branding

accounting_log = logging.getLogger("coin.billing")


def invoice_pdf_filename(instance, filename):
    """Nom et chemin du fichier pdf à stocker pour les factures"""
    member_id = instance.member.id if instance.member else 0
    return 'invoices/%d_%s_%s.pdf' % (member_id,
                                      instance.number,
                                      uuid.uuid4())


@python_2_unicode_compatible
class InvoiceNumber:
    """ Logic and validation of invoice numbers

    Defines invoice numbers serie in a way that is legal in france.

    https://www.service-public.fr/professionnels-entreprises/vosdroits/F23208#fiche-item-3

    Our format is YYYY-MM-XXXXXX
    - YYYY the year of the bill
    - MM month of the bill
    - XXXXXX a per-month sequence
    """
    RE_INVOICE_NUMBER = re.compile(
        r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<index>\d{6})')

    def __init__(self, date, index):
        self.date = date
        self.index = index

    def get_next(self):
        return InvoiceNumber(self.date, self.index + 1)

    def __str__(self):
        return '{:%Y-%m}-{:0>6}'.format(self.date, self.index)

    @classmethod
    def parse(cls, string):
        m = cls.RE_INVOICE_NUMBER.match(string)
        if not m:
            raise ValueError('Not a valid invoice number: "{}"'.format(string))

        return cls(
            datetime.date(
                year=int(m.group('year')),
                month=int(m.group('month')),
                day=1),
            int(m.group('index')))

    @staticmethod
    def time_sequence_filter(date, field_name='date'):
        """ Build queryset filter to be used to get the invoices from the
        numbering sequence of a given date.

        :param field_name: the invoice field name to filter on.

        :type date: datetime
        :rtype: dict
        """

        return {'{}__month'.format(field_name): date.month}


class InvoiceQuerySet(models.QuerySet):
    def get_next_invoice_number(self, date):
        last_invoice_number_str = self._get_last_invoice_number(date)

        if last_invoice_number_str is None:
            # It's the first bill of the month
            invoice_number = InvoiceNumber(date, 1)
        else:
            invoice_number = InvoiceNumber.parse(last_invoice_number_str).get_next()

        return str(invoice_number)

    def _get_last_invoice_number(self, date):
        same_seq_filter = InvoiceNumber.time_sequence_filter(date)
        return self.filter(**same_seq_filter).with_valid_number().aggregate(
            models.Max('number'))['number__max']

    def with_valid_number(self):
        """ Excludes previous numbering schemes or draft invoices
        """
        return self.filter(number__regex=postgresql_regexp(
            InvoiceNumber.RE_INVOICE_NUMBER))

class Invoice(models.Model):

    INVOICES_STATUS_CHOICES = (
        ('open', 'A payer'),
        ('closed', 'Reglée'),
        ('trouble', 'Litige')
    )

    validated = models.BooleanField(default=False, verbose_name='validée',
                                    help_text='Once validated, a PDF is generated'
                                    ' and the invoice cannot be modified')
    number = models.CharField(max_length=25,
                              unique=True,
                              verbose_name='numéro')
    status = models.CharField(max_length=50, choices=INVOICES_STATUS_CHOICES,
                              default='open',
                              verbose_name='statut')
    date = models.DateField(
        default=datetime.date.today, null=True, verbose_name='date',
        help_text='Cette date sera définie à la date de validation dans la facture finale')
    date_due = models.DateField(
        default=end_of_month,
        null=True,
        verbose_name="date d'échéance de paiement")
    member = models.ForeignKey(Member, null=True, blank=True, default=None,
                               related_name='invoices',
                               verbose_name='membre',
                               on_delete=models.SET_NULL)
    pdf = models.FileField(storage=private_files_storage,
                           upload_to=invoice_pdf_filename,
                           null=True, blank=True,
                           verbose_name='PDF')

    amount_paid = models.DecimalField(max_digits=5,
                                      decimal_places=2,
                                      default=0,
                                      verbose_name='montant payé')

    def save(self, *args, **kwargs):

        # First save to get a PK
        super(Invoice, self).save(*args, **kwargs)

        if not self.validated:
            if self.number:
                accounting_log.info("Creating/updating draft invoice %s."
                                    % self.number)
            if not self.number and self.pk:
                # Use pk to build draft invoice number if needed
                self.number = 'DRAFT-{}'.format(self.pk)
                self.save()

    def amount(self):
        """
        Calcul le montant de la facture
        en fonction des éléments de détails
        """
        total = Decimal('0.0')
        for detail in self.details.all():
            total += detail.total()
        return total.quantize(Decimal('0.01'))
    amount.short_description = 'Montant'

    def amount_remaining_to_pay(self):
        """
        Calcul le montant restant à payer
        """
        return self.amount() - self.amount_paid
    amount_remaining_to_pay.short_description = 'Reste à payer'

    def has_owner(self, username):
        """
        Check if passed username (ex gmajax) is owner of the invoice
        """
        return (self.member and self.member.username == username)

    def generate_pdf(self):
        """
        Make and store a pdf file for the invoice
        """
        context = {"invoice": self}
        context.update(branding(None))
        pdf_file = render_as_pdf('billing/invoice_pdf.html', context)
        self.pdf.save('%s.pdf' % self.number, pdf_file)

    @transaction.atomic
    def validate(self):
        """
        Switch invoice to validate mode. This set to False the draft field
        and generate the pdf
        """
        self.date = datetime.date.today()
        old_number = self.number
        self.number = Invoice.objects.get_next_invoice_number(self.date)

        self.validated = True
        self.save()
        self.generate_pdf()

        accounting_log.info("Draft invoice %s validated as invoice %s. "
                            "(Total amount : %f ; Member : %s)"
                            % (old_number, self.number, self.amount(), self.member))
        assert self.pdf_exists()
        if self.member is not None:
            update_accounting_for_member(self.member)


    def pdf_exists(self):
        return (self.validated
                and bool(self.pdf)
                and private_files_storage.exists(self.pdf.name))

    def get_absolute_url(self):
        from django.core.urlresolvers import reverse
        return reverse('billing:invoice', args=[self.number])

    def __unicode__(self):
        return '#%s %0.2f€ %s' % (self.number, self.amount(), self.date_due)

    class Meta:
        verbose_name = 'facture'

    objects = InvoiceQuerySet().as_manager()


class InvoiceDetail(models.Model):

    label = models.CharField(max_length=100)
    amount = models.DecimalField(max_digits=5, decimal_places=2,
                                 verbose_name='montant')
    quantity = models.DecimalField(null=True, verbose_name='quantité',
                                   default=1.0, decimal_places=2, max_digits=4)
    tax = models.DecimalField(null=True, default=0.0, decimal_places=2,
                              max_digits=4, verbose_name='TVA',
                              help_text='en %')
    invoice = models.ForeignKey(Invoice, verbose_name='facture',
                                related_name='details')
    offersubscription = models.ForeignKey(OfferSubscription, null=True,
                                          blank=True, default=None,
                                          verbose_name='abonnement')
    period_from = models.DateField(
        default=start_of_month,
        null=True,
        blank=True,
        verbose_name='début de période',
        help_text='Date de début de période sur laquelle est facturé cet item')
    period_to = models.DateField(
        default=end_of_month,
        null=True,
        blank=True,
        verbose_name='fin de période',
        help_text='Date de fin de période sur laquelle est facturé cet item')

    def __unicode__(self):
        return self.label

    def total(self):
        """Calcul le total"""
        return (self.amount * (self.tax / Decimal('100.0') +
                               Decimal('1.0')) *
                self.quantity).quantize(Decimal('0.01'))

    class Meta:
        verbose_name = 'détail de facture'


class Payment(models.Model):

    PAYMENT_MEAN_CHOICES = (
        ('cash', 'Espèces'),
        ('check', 'Chèque'),
        ('transfer', 'Virement'),
        ('other', 'Autre')
    )

    member = models.ForeignKey(Member, null=True, blank=True, default=None,
                               related_name='payments',
                               verbose_name='membre',
                               on_delete=models.SET_NULL)

    payment_mean = models.CharField(max_length=100, null=True,
                                    default='transfer',
                                    choices=PAYMENT_MEAN_CHOICES,
                                    verbose_name='moyen de paiement')
    amount = models.DecimalField(max_digits=5, decimal_places=2, null=True,
                                 verbose_name='montant')
    date = models.DateField(default=datetime.date.today)
    invoice = models.ForeignKey(Invoice, verbose_name='facture associée', null=True,
                                blank=True, related_name='payments')

    amount_already_allocated = models.DecimalField(max_digits=5,
                                                   decimal_places=2,
                                                   null=True, blank=True, default=0.0,
                                                   verbose_name='montant déjà alloué')

    label = models.CharField(max_length=500,
                             null=True, blank=True, default="",
                             verbose_name='libellé')

    def save(self, *args, **kwargs):
        super(Payment, self).save(*args, **kwargs)

        # If this payment is related to a member, update the accounting for
        # this member
        if self.member != None:
            update_accounting_for_member(self.member)

    def amount_not_allocated(self):
        return self.amount - self.amount_already_allocated

    @transaction.atomic
    def allocate_to_invoice(self, invoice):
        amount_can_pay = self.amount_not_allocated()
        amount_to_pay  = invoice.amount_remaining_to_pay()
        amount_to_allocate = min(amount_can_pay, amount_to_pay)

        accounting_log.info("Allocating %f from payment %s to invoice %s"
                            % (float(amount_to_allocate), str(self.date),
                               invoice.number))

        self.amount_already_allocated += amount_to_allocate
        invoice.amount_paid           += amount_to_allocate

        # Close invoice if relevant
        if (invoice.amount_remaining_to_pay() <= 0) and (invoice.status == "open"):
            accounting_log.info("Invoice %s has been paid and is now closed"
                                % invoice.number)
            invoice.status = "closed"

        invoice.save()
        self.save()

    @property
    def name(self):
        return str(self)

    def __unicode__(self):
        if self.member is not None:
            return 'Paiment de %0.2f€ le %s par %s' \
                    % (self.amount, str(self.date), self.member)
        else:
            return 'Paiment de %0.2f€ le %s' \
                    % (self.amount, str(self.date))

    class Meta:
        verbose_name = 'paiement'


def update_accounting_for_member(member):
    """
    Met à jour le status des factures, des paiements et le solde du compte
    d'un utilisateur
    """

    accounting_log.info("Member %s current balance is %f ..."
                        % (str(member), float(member.balance)))
    accounting_log.info("Updating accounting for member %s ..."
                        % str(member))

    # Fetch relevant and active payments / invoices
    # and sort then by chronological order : olders first, newers last.

    this_member_invoices = [i for i in member.invoices.filter(validated=True)
                                                      .order_by("date")]
    this_member_payments = [p for p in member.payments.order_by("date")]

    # TODO / FIXME ^^^ maybe also consider only 'opened' invoices (i.e. not
    # conflict / trouble invoices)

    number_of_active_payments = len([p for p in this_member_payments if p.amount_not_allocated()    > 0])
    number_of_active_invoices = len([p for p in this_member_invoices if p.amount_remaining_to_pay() > 0])

    if (number_of_active_payments == 0):
        accounting_log.info("(No active payment for %s. No invoice/payment "
                            "reconciliation needed for now.)."
                            % str(member))
    elif (number_of_active_invoices == 0):
        accounting_log.info("(No active invoice for %s. No invoice/payment "
                            "reconciliation needed for now.)."
                            % str(member))
    else:
        accounting_log.info("Initiating reconciliation between "
                            "invoice and payments for %s" % str(member))
        reconcile_invoices_and_payments(this_member_invoices,
                                        this_member_payments)

    member.balance = compute_balance(this_member_invoices,
                                     this_member_payments)
    member.save()

    accounting_log.info("Member %s new balance is %f"
                        % (str(member),  float(member.balance)))


def reconcile_invoices_and_payments(invoices, payments):
    """
    Rapproche des factures et des paiements qui sont actifs (paiement non alloué
    ou factures non entièrement payées) automatiquement.
    Retourne la balance restante (positive si 'trop payé', négative si factures
    restantes à payer)
    """

    active_payments = [p for p in payments if p.amount_not_allocated()    > 0]
    active_invoices = [i for i in invoices if i.amount_remaining_to_pay() > 0]

    if (len(active_payments) == 0):
        accounting_log.info("No more active payment. Nothing to reconcile "
                            "anymore.")
        return
    if (len(active_invoices) == 0):
        accounting_log.info("No more active invoice. Nothing to reconcile "
                            "anymore.")
        return

    # Only consider the oldest active payment and the oldest active invoice

    p = active_payments[0]
    i = active_invoices[0]

    # TODO : should add an assert that the ammount not allocated / remaining to
    # pay is lower before and after calling the allocate_to_invoice

    p.allocate_to_invoice(i)

    # Reconcicle next payment / invoice

    reconcile_invoices_and_payments(invoices, payments)


def compute_balance(invoices, payments):

    active_payments = [p for p in payments if p.amount_not_allocated()    > 0]
    active_invoices = [i for i in invoices if i.amount_remaining_to_pay() > 0]

    s = 0
    s -= sum([i.amount_remaining_to_pay() for i in active_invoices])
    s += sum([p.amount_not_allocated()    for p in active_payments])

    return s


def test_accounting_update():

    Member.objects.all().delete()
    Payment.objects.all().delete()
    Invoice.objects.all().delete()

    johndoe =  Member.objects.create(username="johndoe",
                                     first_name="John",
                                     last_name="Doe",
                                     email="johndoe@yolo.test")
    johndoe.set_password("trololo")


    # First facture
    invoice = Invoice.objects.create(number="1337",
                                     member=johndoe)
    InvoiceDetail.objects.create(label="superservice",
                                 amount="15.0",
                                 invoice=invoice)
    invoice.validate()

    # Second facture
    invoice2 = Invoice.objects.create(number="42",
                                     member=johndoe)
    InvoiceDetail.objects.create(label="superservice",
                                 amount="42",
                                 invoice=invoice2)
    invoice2.validate()

    # Payment
    payment = Payment.objects.create(amount=20,
                                     member=johndoe)

    Member.objects.all().delete()
    Payment.objects.all().delete()
    Invoice.objects.all().delete()