Produits Entr'ouvert » Calebasse

# -*- coding: utf-8 -*-

import tempfile

from datetime import date, datetime

from dateutil.relativedelta import relativedelta

from decimal import Decimal

from django.db import models

from django.db.models import Max, Q

from model_utils import Choices

from calebasse.dossiers.models import PatientRecord

from calebasse.ressources.models import (ServiceLinkedManager, PricePerAct,

    HealthCenter)

import list_acts

import progor

from batches import build_batches

def social_security_id_full(nir):

    old = nir

    try:

        # Corse dpt 2A et 2B

        minus = 0

        if nir[6] in ('A', 'a'):

            nir = [c for c in nir]

            nir[6] = '0'

            nir = ''.join(nir)

            minus = 1000000

        elif nir[6] in ('B', 'b'):

            nir = [c for c in nir]

            nir[6] = '0'

            nir = ''.join(nir)

            minus = 2000000

        nir = int(nir) - minus

        return old + ' %0.2d' % (97 - (nir % 97))

    except Exception, e:

        return old + ' 00'

def quarter_start_and_end_dates(today=None):

    '''Returns the first and last day of the current quarter'''

    if today is None:

        today = date.today()

    quarter = (today.month - 1) / 3

    start_date = date(day=1, month=((quarter*3) + 1), year=today.year)

    end_date = start_date + relativedelta(months=3) + relativedelta(days=-1)

    return start_date, end_date

class InvoicingManager(ServiceLinkedManager):

    def current_for_service(self, service):

        '''Return the currently open invoicing'''

        if service.name != 'CMPP':

            start_date, end_date = quarter_start_and_end_dates()

            invoicing, created = \

                self.get_or_create(start_date=start_date,

                end_date=end_date, service=service)

            if created:

                invoicing.status = Invoicing.STATUS.closed

                invoicing.save()

        else:

            try:

                invoicing = self.get(service=service,

                        status=Invoicing.STATUS.open)

            except Invoicing.DoesNotExist:

                today = date.today()

                start_date = date(day=today.day, month=today.month, year=today.year)

                invoicing, created = self.get_or_create(service=service,

                    start_date=start_date,

                    status=Invoicing.STATUS.open)

        return invoicing

    def last_for_service(self, service):

        current = self.current_for_service(service)

        last_seq_id = current.seq_id - 1

        try:

            return self.get(service=service,

                seq_id=last_seq_id)

        except:

            return None

def build_invoices_from_acts(acts_diagnostic, acts_treatment):

    invoices = {}

    len_invoices = 0

    len_invoices_hors_pause = 0

    len_acts_invoiced = 0

    len_acts_invoiced_hors_pause = 0

    pricing = PricePerAct.pricing()

    for patient, acts in acts_diagnostic.items():

        invoices[patient] = []

        act, hc = acts[0]

        invoice = dict()

        invoice['ppa'] = pricing.price_at_date(act.date)

        invoice['year'] = act.date.year

        invoice['acts'] = [(act, hc)]

        if len(acts) > 1:

            for act, hc in acts[1:]:

                if invoice['ppa'] != pricing.price_at_date(act.date) or \

                        invoice['year'] != act.date.year:

                    invoices[patient].append(invoice)

                    len_invoices += 1

                    len_acts_invoiced += len(invoice['acts'])

                    if not patient.pause:

                        len_invoices_hors_pause += 1

                        len_acts_invoiced_hors_pause += len(invoice['acts'])

                    invoice = dict()

                    invoice['ppa'] = pricing.price_at_date(act.date)

                    invoice['year'] = act.date.year

                    invoice['acts'] = [(act, hc)]

                else:

                    invoice['acts'].append((act, hc))

        invoices[patient].append(invoice)

        len_invoices += 1

        len_acts_invoiced += len(invoice['acts'])

        if not patient.pause:

            len_invoices_hors_pause += 1

            len_acts_invoiced_hors_pause += len(invoice['acts'])

    pricing = PricePerAct.pricing()

    for patient, acts in acts_treatment.items():

        if not patient in invoices:

            invoices[patient] = []

        act, hc = acts[0]

        invoice = dict()

        invoice['ppa'] = pricing.price_at_date(act.date)

        invoice['year'] = act.date.year

        invoice['acts'] = [(act, hc)]

        if len(acts) > 1:

            for act, hc in acts[1:]:

                if invoice['ppa'] != pricing.price_at_date(act.date) or \

                        invoice['year'] != act.date.year:

                    invoices[patient].append(invoice)

                    len_invoices += 1

                    len_acts_invoiced += len(invoice['acts'])

                    if not patient.pause:

                        len_invoices_hors_pause += 1

                        len_acts_invoiced_hors_pause += len(invoice['acts'])

                    invoice = dict()

                    invoice['ppa'] = pricing.price_at_date(act.date)

                    invoice['year'] = act.date.year

                    invoice['acts'] = [(act, hc)]

                else:

                    invoice['acts'].append((act, hc))

        invoices[patient].append(invoice)

        len_invoices += 1

        len_acts_invoiced += len(invoice['acts'])

        if not patient.pause:

            len_invoices_hors_pause += 1

            len_acts_invoiced_hors_pause += len(invoice['acts'])

    return (invoices, len_invoices, len_invoices_hors_pause,

        len_acts_invoiced, len_acts_invoiced_hors_pause)

# The firts cmpp invoicing with calebasse

INVOICING_OFFSET = 134

class Invoicing(models.Model):

    '''Represent a batch of invoices:

       end_date - only acts before this date will be considered

       status   - current status of the invoicing

       acts     - acts bounded to this invoicing when the invoicing is validated

       STATUS - the possible status:

        - open, the invoicing is open for new acts

        - closed, invoicing has been closed, no new acts will be accepted after

          the end_date,

        - validated,

    '''

    STATUS = Choices('open', 'closed', 'validated', 'sent')

    seq_id = models.IntegerField(blank=True, null=True)

    service = models.ForeignKey('ressources.Service', on_delete=models.PROTECT)

    start_date = models.DateField(

            verbose_name=u'Ouverture de la facturation')

    end_date = models.DateField(

            verbose_name=u'Clôturation de la facturation',

            blank=True,

            null=True)

    status = models.CharField(

            verbose_name=u'Statut',

            choices=STATUS,

            default=STATUS.open,

            max_length=20)

    acts = models.ManyToManyField('actes.Act')

    objects = InvoicingManager()

    class Meta:

        unique_together = (('seq_id', 'service'),)

    def allocate_seq_id(self):

        '''Allocate a new sequence id for a new invoicing.'''

        seq_id = 1

        max_seq_id = Invoicing.objects.for_service(self.service) \

                .aggregate(Max('seq_id'))['seq_id__max']

        if not max_seq_id:

            if self.service.name == 'CMPP':

                seq_id = INVOICING_OFFSET

        else:

            seq_id = max_seq_id + 1

        return seq_id

    def list_for_billing(self):

        '''Return the acts candidates for billing'''

        if self.service.name == 'CMPP':

            end_date = self.end_date

            if not end_date:

                today = date.today()

                end_date = date(day=today.day, month=today.month, year=today.year)

            return list_acts.list_acts_for_billing_CMPP(end_date,

                    service=self.service)

        elif self.service.name == 'CAMSP':

            return list_acts.list_acts_for_billing_CAMSP(self.start_date,

                    self.end_date, service=self.service)

        elif 'SESSAD' in self.service.name:

            return list_acts.list_acts_for_billing_SESSAD(self.start_date,

                    self.end_date, service=self.service)

        else:

            raise RuntimeError('Unknown service', self.service)

    def get_batches(self):

        batches = list()

        for hc, bs in build_batches(self).iteritems():

            for batch in bs:

                amount_rejected = sum([invoice.decimal_amount

                    for invoice in batch.invoices

                    if invoice.rejected])

                versement = batch.total - amount_rejected

                batches.append((hc, batch, amount_rejected, versement))

        return batches

    def get_stats_per_price_per_year(self):

        stats_final = dict()

        stats_final['total'] = (0, 0)

        stats_final['detail'] = dict()

        if self.service.name != 'CMPP' or \

                self.status in (Invoicing.STATUS.open,

                Invoicing.STATUS.closed):

            return stats_final

        stats = stats_final['detail']

        invoices = self.invoice_set.all()

        for invoice in invoices:

            if not invoice.list_dates:

                continue

            # All acts of an invoice are the same year and at the same price

            dates = invoice.list_dates.split('$')

            year = datetime.strptime(dates[0], "%d/%m/%Y").year

            ppa = invoice.decimal_ppa

            if year not in stats:

                stats[year] = dict()

            if ppa not in stats[year]:

                stats[year][ppa] = (0, 0)

            nb_acts, amount = stats[year][ppa]

            nb_acts += len(dates)

            amount += invoice.decimal_amount

            stats[year][ppa] = (nb_acts, amount)

            nb_acts_f, amount_f = stats_final['total']

            nb_acts_f += invoice.acts.count()

            amount_f += invoice.decimal_amount

            stats_final['total'] = (nb_acts_f, amount_f)

        return stats_final

    def get_stats_or_validate(self, commit=False):

        '''

            If the invoicing is in state open or closed and commit is False

                Return the stats of the billing

            If the invoicing is in state open or closed and commit is True

                Proceed to invoices creation, healthcare charging, acts as billed

                Return the stats of the billing

            If the invoicing is in state validated or sent

                Return the stats of the billing

        '''

        days_not_locked = 0

        if self.service.name == 'CMPP':

            if self.status in (Invoicing.STATUS.open,

                    Invoicing.STATUS.closed):

                '''

                    The stats are build dynamiccaly according to the

                    acts billable and the healthcares

                '''

                (acts_not_locked, days_not_locked, acts_not_valide,

                    acts_not_billable, acts_pause, acts_diagnostic,

                    acts_treatment, acts_losts,

                    acts_losts_missing_policy,

                    acts_losts_missing_birthdate) = \

                        self.list_for_billing()

                (invoices, len_invoices, len_invoices_hors_pause,

                    len_acts_invoiced, len_acts_invoiced_hors_pause) = \

                        build_invoices_from_acts(acts_diagnostic, acts_treatment)

                len_patient_invoiced = len(invoices.keys())

                len_patient_invoiced_hors_pause = 0

                for patient in invoices.keys():

                    if not patient.pause:

                        len_patient_invoiced_hors_pause = len_patient_invoiced_hors_pause + 1

                patients = set(acts_diagnostic.keys() + acts_treatment.keys() + \

                    acts_losts.keys() + acts_pause.keys() + acts_losts_missing_policy.keys() + \

                    acts_losts_missing_birthdate.keys())

                patients_stats = []

                len_patient_with_lost_acts = 0

                len_acts_lost = 0

                len_patient_acts_paused = 0

                len_acts_paused = 0

                len_patient_with_lost_acts_missing_policy = 0

                len_acts_losts_missing_policy = 0

                len_patient_with_lost_acts_missing_birthdate = 0

                len_acts_losts_missing_birthdate = 0

                batches = {}

                last_batch = {}

                for patient in patients:

                    dic = {}

                    if patient in invoices.keys():

                        dic['invoices'] = invoices[patient]

                        if commit and not patient.pause:

                            policy_holder = patient.policyholder

                            try:

                                address = unicode(policy_holder.addresses.filter(place_of_life=True)[0])

                            except:

                                try:

                                    address = unicode(policy_holder.addresses.all()[0])

                                except:

                                    address = u''

                            invoice_kwargs = dict(

                                    patient_id=patient.id,

                                    patient_last_name=patient.last_name,

                                    patient_first_name=patient.first_name,

                                    patient_social_security_id=patient.social_security_id or '',

                                    patient_birthdate=patient.birthdate,

                                    patient_twinning_rank=patient.twinning_rank,

                                    patient_healthcenter=patient.health_center,

                                    patient_other_health_center=patient.other_health_center or '',

                                    patient_entry_date=patient.entry_date,

                                    patient_exit_date=patient.exit_date,

                                    policy_holder_id=policy_holder.id,

                                    policy_holder_last_name=policy_holder.last_name,

                                    policy_holder_first_name=policy_holder.first_name,

                                    policy_holder_social_security_id=policy_holder.social_security_id,

                                    policy_holder_other_health_center=policy_holder.other_health_center or '',

                                    policy_holder_healthcenter=policy_holder.health_center,

                                    policy_holder_address=address)

                            for invoice in invoices[patient]:

                                ppa = invoice['ppa'] * 100

                                acts = invoice['acts']

                                amount = ppa * len(acts)

                                list_dates = '$'.join([act.date.strftime('%d/%m/%Y') for act, hc in acts])

                                in_o = Invoice(

                                        invoicing=self,

                                        ppa=ppa,

                                        amount=amount,

                                        list_dates = list_dates,

                                        **invoice_kwargs)

                                in_o.save()

                                for act, hc in acts:

                                    act.is_billed = True

                                    act.healthcare = hc

                                    act.save()

                                    in_o.acts.add(act)

                                in_o.first_tag = acts[0][0].get_hc_tag()

                                in_o.save()

                                # calcule le numero de lot pour cette facture

                                hc = in_o.health_center

                                hc_dest = hc.hc_invoice or hc

                                dest = hc_dest.large_regime.code + ' ' + hc_dest.dest_organism

                                if dest not in batches:

                                    batches[dest] = {}

                                if hc not in batches[dest]:

                                    nb1 = Invoice.objects.new_batch_number(health_center=hc_dest, invoicing=self)

                                    nb2 = Invoice.objects.new_batch_number(health_center=hc, invoicing=self)

                                    nb = max(nb1, nb2, last_batch.get(dest,0) + 1)

                                    last_batch[dest] = nb

                                    batches[dest][hc] = [{ 'batch': nb, 'size': 2, 'invoices': [], }]

                                # pas plus de 950 lignes par lot (le fichier B2 final ne doit

                                # pas depasser 999 lignes au total) :

                                b = batches[dest][hc].pop()

                                b2_size = in_o.acts.count() + 2

                                if (b['size'] + b2_size) > 950:

                                    batches[dest][hc].append(b)

                                    nb = last_batch.get(dest, 0) + 1

                                    last_batch[dest] = nb

                                    b = {'batch': nb, 'size': 2, 'invoices': []}

                                b['invoices'].append(in_o)

                                b['size'] += b2_size

                                batches[dest][hc].append(b)

                                in_o.batch = b['batch']

                                in_o.save()

                    if patient in acts_losts.keys():

                        # TODO: More details about healthcare

                        dic['losts'] = acts_losts[patient]

                        len_patient_with_lost_acts += 1

                        len_acts_lost += len(acts_losts[patient])

                    if patient in acts_pause.keys():

                        dic['acts_paused'] = acts_pause[patient]

                        len_patient_acts_paused += 1

                        len_acts_paused += len(acts_pause[patient])

                    if patient in acts_losts_missing_policy.keys():

                        # TODO: More details about healthcare

                        dic['losts_missing_policy'] = acts_losts_missing_policy[patient]

                        len_patient_with_lost_acts_missing_policy += 1

                        len_acts_losts_missing_policy += len(acts_losts_missing_policy[patient])

                    if patient in acts_losts_missing_birthdate.keys():

                        dic['losts_missing_birthdate'] = acts_losts_missing_birthdate[patient]

                        len_patient_with_lost_acts_missing_birthdate += 1

                        len_acts_losts_missing_birthdate += len(acts_losts_missing_birthdate[patient])

                    if dic:

                        patients_stats.append((patient, dic))

                patients_stats = sorted(patients_stats, key=lambda patient: (patient[0].last_name, patient[0].first_name))

                len_patients = len(patients_stats)

                if commit:

                    self.status = Invoicing.STATUS.validated

                    self.save()

            else:

                '''

                    Grab stats from the invoices

                '''

                len_patients = 0

                len_invoices = 0

                len_acts_invoiced = 0

                patients_stats = {}

                days_not_locked = []

                invoices = self.invoice_set.all()

                patients = {}

                for invoice in invoices:

                    len_invoices = len_invoices + 1

                    if invoice.list_dates:

                        len_acts_invoiced += len(invoice.list_dates.split('$'))

                    patient = None

                    if not invoice.patient_id in patients.keys():

                        try:

                            patient = PatientRecord.objects.get(id=invoice.patient_id)

                        except:

                            patient = PatientRecord(last_name=invoice.patient_last_name, first_name=invoice.patient_first_name)

                        patients[invoice.patient_id] = patient

                        len_patients = len_patients + 1

                        patients_stats[patient] = {}

                        patients_stats[patient]['invoices'] = []

                    else:

                        patient = patients[invoice.patient_id]

                    patients_stats[patient]['invoices'].append(invoice)

                patients_stats = sorted(patients_stats.items(), key=lambda patient: (patient[0].last_name, patient[0].first_name))

                # all patients in the invoicing are invoiced

                len_patient_invoiced = 0

                # These stats are not necessary because excluded form the validated invoicing

                len_invoices_hors_pause = 0

                len_acts_invoiced_hors_pause = 0

                len_patient_invoiced_hors_pause = 0

                len_acts_lost = 0

                len_patient_with_lost_acts = 0

                len_patient_acts_paused = 0

                len_acts_paused = 0

                len_patient_with_lost_acts_missing_policy = 0

                len_acts_losts_missing_policy = 0

                len_patient_with_lost_acts_missing_birthdate = 0

                len_acts_losts_missing_birthdate = 0

            return (len_patients, len_invoices, len_invoices_hors_pause,

                len_acts_invoiced, len_acts_invoiced_hors_pause,

                len_patient_invoiced, len_patient_invoiced_hors_pause,

                len_acts_lost, len_patient_with_lost_acts, patients_stats,

                days_not_locked, len_patient_acts_paused,

                len_acts_paused, len_acts_losts_missing_policy,

                len_patient_with_lost_acts_missing_policy,

                len_acts_losts_missing_birthdate,

                len_patient_with_lost_acts_missing_birthdate)

        elif self.service.name == 'CAMSP':

            if self.status in Invoicing.STATUS.closed:

                (acts_not_locked, days_not_locked, acts_not_valide,

                acts_not_billable, acts_pause, acts_bad_state,

                acts_accepted, patients_missing_policy) = self.list_for_billing()

                len_patient_pause = 0

                len_patient_hors_pause = 0

                len_acts_pause = 0

                len_acts_hors_pause = 0

                len_patient_acts_paused = 0

                len_acts_paused = 0

                patients = set(acts_accepted.keys() + acts_pause.keys())

                patients_stats = []

                for patient in patients:

                    dic = {}

                    if patient in acts_accepted.keys():

                        acts = acts_accepted[patient]

                        dic['accepted'] = acts

                        if patient.pause:

                            len_patient_pause += 1

                            len_acts_pause += len(acts)

                        else:

                            len_patient_hors_pause += 1

                            len_acts_hors_pause += len(acts)

                            if commit:

                                policy_holder = patient.policyholder

                                try:

                                    address = unicode(policy_holder.addresses.filter(place_of_life=True)[0])

                                except:

                                    try:

                                        address = unicode(policy_holder.addresses.all()[0])

                                    except:

                                        address = u''

                                invoice_kwargs = dict(

                                        patient_id=patient.id,

                                        patient_last_name=patient.last_name,

                                        patient_first_name=patient.first_name,

                                        patient_social_security_id=patient.social_security_id or '',

                                        patient_birthdate=patient.birthdate,

                                        patient_twinning_rank=patient.twinning_rank,

                                        patient_healthcenter=patient.health_center,

                                        patient_other_health_center=patient.other_health_center or '',

                                        patient_entry_date=patient.entry_date,

                                        patient_exit_date=patient.exit_date,

                                        policy_holder_id=policy_holder.id,

                                        policy_holder_last_name=policy_holder.last_name,

                                        policy_holder_first_name=policy_holder.first_name,

                                        policy_holder_social_security_id=policy_holder.social_security_id or '',

                                        policy_holder_other_health_center=policy_holder.other_health_center or '',

                                        policy_holder_healthcenter=policy_holder.health_center,

                                        policy_holder_address=address)

                                if policy_holder.management_code:

                                    management_code = policy_holder.management_code

                                    invoice_kwargs['policy_holder_management_code'] = management_code.code

                                    invoice_kwargs['policy_holder_management_code_name'] = management_code.name

                                list_dates = '$'.join([act.date.strftime('%d/%m/%Y') for act in acts])

                                invoice = Invoice(

                                        invoicing=self,

                                        ppa=0, amount=0,

                                        list_dates=list_dates,

                                        **invoice_kwargs)

                                invoice.save()

                                for act in acts:

                                    act.is_billed = True

                                    act.save()

                                    invoice.acts.add(act)

                    if patient in acts_pause.keys():

                        dic['acts_paused'] = acts_pause[patient]

                        len_patient_acts_paused += 1

                        len_acts_paused += len(acts_pause[patient])

                    patients_stats.append((patient, dic))

                patients_stats = sorted(patients_stats, key=lambda patient: (patient[0].last_name, patient[0].first_name))

                if commit:

                    self.status = Invoicing.STATUS.validated

                    self.save()

            else:

                patients_stats = {}

                len_patient_pause = 0

                len_patient_hors_pause = 0

                len_acts_pause = 0

                len_acts_hors_pause = 0

                len_patient_acts_paused = 0

                len_acts_paused = 0

                days_not_locked = []

                patients_missing_policy = []

                invoices = self.invoice_set.all()

                for invoice in invoices:

                    len_patient_hors_pause += 1

                    if invoice.list_dates:

                        len_acts_hors_pause += len(invoice.list_dates.split('$'))

                    patient = None

                    try:

                        patient = PatientRecord.objects.get(id=invoice.patient_id)

                    except:

                        patient = PatientRecord(last_name=invoice.patient_last_name, first_name=invoice.patient_first_name)

                    patients_stats[patient] = {}

                    patients_stats[patient]['accepted'] = invoice.acts.all()

                patients_stats = sorted(patients_stats.items(), key=lambda patient: (patient[0].last_name, patient[0].first_name))

            return (len_patient_pause, len_patient_hors_pause,

                len_acts_pause, len_acts_hors_pause, patients_stats,

                days_not_locked, len_patient_acts_paused,

                len_acts_paused, patients_missing_policy)

        else:

            if self.status in Invoicing.STATUS.closed:

                (acts_not_locked, days_not_locked, acts_not_valide,

                acts_not_billable, acts_pause, acts_bad_state,

                acts_missing_valid_notification, acts_accepted,

                patients_missing_policy) = \

                    self.list_for_billing()

                len_patient_pause = 0

                len_patient_hors_pause = 0

                len_acts_pause = 0

                len_acts_hors_pause = 0

                len_patient_acts_paused = 0

                len_acts_paused = 0

                len_patient_missing_notif = 0

                len_acts_missing_notif = 0

                patients = set(acts_accepted.keys() + \

                    acts_missing_valid_notification.keys() + \

                    acts_pause.keys())

                patients_stats = []

                patients_missing_notif = []

                for patient in patients:

                    dic = {}

                    acts_to_commit = []

                    if patient in acts_accepted.keys():

                        acts = acts_accepted[patient]

                        acts_to_commit.extend(acts)

                        dic['accepted'] = acts

                        if patient.pause:

                            len_patient_pause += 1

                            len_acts_pause += len(acts)

                        else:

                            len_patient_hors_pause += 1

                            len_acts_hors_pause += len(acts)

                    if patient in acts_missing_valid_notification.keys():

                        patients_missing_notif.append(patient)

                        acts = acts_missing_valid_notification[patient]

                        acts_to_commit.extend(acts)

                        dic['missings'] = acts

                        len_patient_missing_notif += 1

                        len_acts_missing_notif += len(acts)

                        if patient.pause:

                            if not 'accepted' in dic:

                                len_patient_pause += 1

                            len_acts_pause += len(acts)

                        else:

                            if not 'accepted' in dic:

                                len_patient_hors_pause += 1

                            len_acts_hors_pause += len(acts)

                    if commit and acts_to_commit:

                        policy_holder = patient.policyholder

                        try:

                            address = unicode(policy_holder.addresses.filter(place_of_life=True)[0])

                        except:

                            try:

                                address = unicode(policy_holder.addresses.all()[0])

                            except:

                                address = u''

                        invoice_kwargs = dict(

                                patient_id=patient.id,

                                patient_last_name=patient.last_name,

                                patient_first_name=patient.first_name,

                                patient_social_security_id=patient.social_security_id or '',

                                patient_birthdate=patient.birthdate,

                                patient_twinning_rank=patient.twinning_rank,

                                patient_healthcenter=patient.health_center,

                                patient_other_health_center=patient.other_health_center or '',

                                patient_entry_date=patient.entry_date,

                                patient_exit_date=patient.exit_date,

                                policy_holder_id=policy_holder.id,

                                policy_holder_last_name=policy_holder.last_name,

                                policy_holder_first_name=policy_holder.first_name,

                                policy_holder_social_security_id=policy_holder.social_security_id or '',

                                policy_holder_other_health_center=policy_holder.other_health_center or '',

                                policy_holder_healthcenter=policy_holder.health_center,

                                policy_holder_address=address)

                        if policy_holder.management_code:

                            management_code = policy_holder.management_code

                            invoice_kwargs['policy_holder_management_code'] = management_code.code

                            invoice_kwargs['policy_holder_management_code_name'] = management_code.name

                        list_dates = '$'.join([act.date.strftime('%d/%m/%Y') for act in acts_to_commit])

                        invoice = Invoice(

                                invoicing=self,

                                ppa=0, amount=0,

                                list_dates=list_dates,

                                **invoice_kwargs)

                        invoice.save()

                        for act in acts_to_commit:

                            act.is_billed = True

                            act.save()

                            invoice.acts.add(act)

                    if patient in acts_pause.keys():

                        dic['acts_paused'] = acts_pause[patient]

                        len_patient_acts_paused += 1

                        len_acts_paused += len(acts_pause[patient])

                    patients_stats.append((patient, dic))

                patients_stats = sorted(patients_stats, key=lambda patient: (patient[0].last_name, patient[0].first_name))

                if commit:

                    self.status = Invoicing.STATUS.validated

                    self.save()

            else:

                patients_stats = {}

                len_patient_pause = 0

                len_patient_hors_pause = 0

                len_acts_pause = 0

                len_acts_hors_pause = 0

                len_patient_acts_paused = 0

                len_acts_paused = 0

                len_patient_missing_notif = 0

                len_acts_missing_notif = 0

                days_not_locked = []

                patients_missing_policy = []

                patients_missing_notif = []

                invoices = self.invoice_set.all()

                for invoice in invoices:

                    len_patient_hors_pause += 1

                    if invoice.list_dates:

                        len_acts_hors_pause += len(invoice.list_dates.split('$'))

                    patient = None

                    try:

                        patient = PatientRecord.objects.get(id=invoice.patient_id)

                    except:

                        patient = PatientRecord(last_name=invoice.patient_last_name, first_name=invoice.patient_first_name)

                    patients_stats[patient] = {}

                    patients_stats[patient]['accepted'] = invoice.acts.all()

                patients_stats = sorted(patients_stats.items(), key=lambda patient: (patient[0].last_name, patient[0].first_name))

            return (len_patient_pause, len_patient_hors_pause,

                len_acts_pause, len_acts_hors_pause,

                len_patient_missing_notif, len_acts_missing_notif,

                patients_stats, days_not_locked,

                len_patient_acts_paused, len_acts_paused,

                patients_missing_policy, patients_missing_notif)

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

        if not self.seq_id:

            self.seq_id = self.allocate_seq_id()

        super(Invoicing, self).save(*args, **kwargs)

    def close(self, end_date=None):

        '''Close an open invoicing'''

        if self.service.name != 'CMPP':

            raise RuntimeError('closing Invoicing is only for the CMPP')

        if self.status != Invoicing.STATUS.open:

            raise RuntimeError('closing an un-opened Invoicing')

        if not end_date:

            today = date.today()

            end_date = date(day=today.day, month=today.month, year=today.year)

            if end_date < self.start_date:

                end_date = self.start_date + relativedelta(days=1)

        self.status = Invoicing.STATUS.closed

        self.end_date = end_date

        self.save()

        start_date = self.end_date + relativedelta(days=1)

        invoicing = Invoicing(service=self.service,

            start_date=start_date,

            status=Invoicing.STATUS.open)