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.conf import settings
from django.db import models, transaction
from django.utils import timezone
from django.utils.encoding import python_2_unicode_compatible
from django.dispatch import receiver
from django.db.models.signals import post_save


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, send_templated_email
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', 'À payer'),
        ('closed', 'Réglé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(
        null=True, blank=True,
        verbose_name="date d'échéance de paiement",
        help_text='Le délai de paiement sera fixé à {} jours à la validation si laissé vide'.format(settings.PAYMENT_DELAY))
    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é')

    date_last_reminder_email = models.DateTimeField(null=True, blank=True,
                        verbose_name="Date du dernier email de relance envoyé")

    def save(self, *args, **kwargs):
        # First save to get a PK
        super(Invoice, self).save(*args, **kwargs)
        # Then use that pk to build draft invoice number
        if not self.validated and self.pk and not self.number:
            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_before_tax(self):
        total = Decimal('0.0')
        for detail in self.details.all():
            total += detail.amount
        return total.quantize(Decimal('0.01'))
    amount_before_tax.short_description = 'Montant HT'

    def amount_paid(self):
        """
        Calcul le montant payé de la facture en fonction des éléments
        de paiements
        """
        total = Decimal('0.0')
        for payment in self.payments.all():
            total += payment.amount
        return total.quantize(Decimal('0.01'))
    amount_paid.short_description = 'Montant payé'

    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()
        if not self.date_due:
            self.date_due = self.date + datetime.timedelta(days=settings.PAYMENT_DELAY)
        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)

    def reminder_needed(self):

        # If there's no member, there's nobody to be reminded
        if self.member is None:
            return False

        # If bill is close or not validated yet, nope
        if self.status != 'open' or not self.validated:
            return False

        from dateutil.relativedelta import relativedelta

        # If bill is not at least one month old, nope
        if self.date_due >= timezone.now()+relativedelta(weeks=-4):
            return False

        # If a reminder has been recently sent, nope
        if (self.date_last_reminder_email
            and (self.date_last_reminder_email
                 >= timezone.now() + relativedelta(weeks=-3))):
            return False

        return True

    def send_reminder(self, auto=False):
        """ Envoie un courrier pour rappeler à un abonné qu'une facture est
        en attente de paiement

        :param bill: id of the bill to remind
        :param auto: is it an auto email? (changes slightly template content)
        """

        if not self.reminder_needed():
            return False

        accounting_log.info("Sending reminder email to %s to pay invoice %s"
                           % (str(self.member), str(self.number)))

        from coin.isp_database.models import ISPInfo

        isp_info = ISPInfo.objects.first()
        kwargs = {}
        # Il peut ne pas y avir d'ISPInfo, ou bien pas d'administrative_email
        if isp_info and isp_info.administrative_email:
            kwargs['from_email'] = isp_info.administrative_email

        # Si le dernier courriel de relance a été envoyé il y a moins de trois
        # semaines, n'envoi pas un nouveau courriel
        send_templated_email(
            to=self.member.email,
            subject_template='billing/emails/reminder_for_unpaid_bill.txt',
            body_template='billing/emails/reminder_for_unpaid_bill.html',
            context={'member': self.member, 'branding': isp_info,
                     'membership_info_url': settings.MEMBER_MEMBERSHIP_INFO_URL,
                     'today': datetime.date.today,
                     'auto_sent': auto},
            **kwargs)

        # Sauvegarde en base la date du dernier envoi de mail de relance
        self.date_last_call_for_membership_fees_email = timezone.now()
        self.save()
        return True

    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 is not 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 get_active_payment_and_invoices(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)

    active_payments = [p for p in this_member_payments if p.amount_not_allocated()    > 0]
    active_invoices = [p for p in this_member_invoices if p.amount_remaining_to_pay() > 0]

    return active_payments, active_invoices


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("Updating accounting for member %s ..."
                        % str(member))
    accounting_log.info("Member %s current balance is %f ..."
                        % (str(member), float(member.balance)))

    reconcile_invoices_and_payments(member)

    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")]

    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(member):
    """
    Rapproche des factures et des paiements qui sont actifs (paiement non alloué
    ou factures non entièrement payées) automatiquement.
    """

    active_payments, active_invoices = get_active_payment_and_invoices(member)

    if active_payments == []:
        accounting_log.info("(No active payment for %s. No invoice/payment "
                            "reconciliation needed.)."
                            % str(member))
        return
    elif active_invoices == []:
        accounting_log.info("(No active invoice for %s. No invoice/payment "
                            "reconciliation needed.)."
                            % str(member))
        return

    accounting_log.info("Initiating reconciliation between "
                        "invoice and payments for %s" % str(member))

    while active_payments != [] and active_invoices != []:

        # 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)

        active_payments, active_invoices = get_active_payment_and_invoices(member)

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


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





@receiver(post_save, sender=Payment)
def payment_changed(sender, instance, created, **kwargs):
    if created:
        accounting_log.info("Adding payment %s (Date: %s, Member: %s, Amount: %s, Label: %s)."
                            % (instance.pk, instance.date, instance.member,
                                instance.amount, instance.label))
    else:
        accounting_log.info("Updating payment %s (Date: %s, Member: %s, Amount: %s, Label: %s, Allocated : )%s."
                            % (instance.pk, instance.date, instance.member,
                                instance.amount, instance.label,
                                instance.amount_already_allocated))


@receiver(post_save, sender=Invoice)
def invoice_changed(sender, instance, created, **kwargs):

    if created:
        accounting_log.info("Creating draft invoice %s (Member: %s)."
                            % ('DRAFT-{}'.format(instance.pk), instance.member))
    else:
        if not instance.validated:
            accounting_log.info("Updating draft invoice %s (Member: %s)."
                    % (instance.number, instance.member))
        else:
            accounting_log.info("Updating invoice %s (Member: %s, Total amount: %s, Amount paid: %s)."
                    % (instance.number, instance.member, instance.amount(), instance.amount_paid ))