|
# -*- coding: utf-8 -*-
|
|
from datetime import datetime
|
|
from collections import defaultdict
|
|
|
|
from django.db.models import Q
|
|
|
|
from calebasse.actes.models import Act
|
|
from calebasse.dossiers.models import (CmppHealthCareDiagnostic,
|
|
CmppHealthCareTreatment)
|
|
|
|
|
|
def list_acts_for_billing_first_round(end_day, service, start_day=None, acts=None, patient=None):
|
|
"""Used to sort acts and extract acts billable before specific service
|
|
requirements.
|
|
|
|
At first, all acts not billed are listed per patient.
|
|
Then acts are sorted.
|
|
Each sorting split the acts in two sets, one set for rejected acts,
|
|
on set for selected sets.
|
|
First sort rejects acts days where all acts are not locked:
|
|
acts_not_locked
|
|
Second sort rejects acts not in state 'VALIDE':
|
|
acts_not_valide
|
|
Third sort rejects acts not billable:
|
|
acts_not_billable
|
|
Acts billable in :
|
|
acts_billable
|
|
|
|
acts = acts_not_locked + \
|
|
acts_not_valide + \
|
|
acts_not_billable + \
|
|
acts_billable
|
|
|
|
:param end_day: formatted date that gives the last day when acts are taken
|
|
in account.
|
|
:type end_day: datetime
|
|
:param service: service in which acts are dealt with.
|
|
:type service: calebasse.ressources.Service
|
|
|
|
:returns: a list of dictionnaries where patients are the keys and values
|
|
are lists of acts. The second element of this list in not a dict but
|
|
a list of the days where are all days are not locked.
|
|
:rtype: list
|
|
"""
|
|
|
|
from calebasse.actes.models import Act
|
|
if isinstance(end_day, datetime):
|
|
end_day = end_day.date()
|
|
if start_day and isinstance(start_day, datetime):
|
|
start_day = start_day.date()
|
|
|
|
acts = Act.objects.filter(validation_locked=False,
|
|
patient__service=service, date__lte=end_day)
|
|
if start_day:
|
|
acts = acts.filter(date__gte=start_day)
|
|
days_not_locked = sorted(set(acts.values_list('date', flat=True)))
|
|
|
|
acts = None
|
|
if patient:
|
|
acts = Act.objects.filter(patient=patient, validation_locked=True,
|
|
is_billed=False, valide=True, is_lost=False,
|
|
patient__service=service, date__lte=end_day)
|
|
else:
|
|
acts = Act.objects.filter(validation_locked=True,
|
|
is_billed=False, valide=True, is_lost=False,
|
|
patient__service=service, date__lte=end_day)
|
|
if start_day:
|
|
acts = acts.filter(date__gte=start_day)
|
|
acts = acts.exclude(date__in=days_not_locked)
|
|
acts = acts.order_by('date')
|
|
|
|
# deprecated
|
|
acts_not_locked = {}
|
|
acts_not_valide = {}
|
|
|
|
acts_pause = {}
|
|
acts_not_billable = {}
|
|
acts_billable = {}
|
|
|
|
|
|
pause_query = Q(pause=True)
|
|
billable_query = Q(act_type__billable=True, switch_billable=False) | \
|
|
Q(act_type__billable=False, switch_billable=True)
|
|
|
|
paused_acts = acts.filter(pause_query).select_related('patient', 'act_type')
|
|
not_billable_acts = acts.filter(~pause_query & ~billable_query).select_related('patient', 'act_type')
|
|
billable_acts = acts.filter(~pause_query & billable_query)
|
|
billable_acts = billable_acts.select_related('act_type', 'patient__policyholder__health_center').prefetch_related('patient__act_set', 'patient__act_set__healthcare')
|
|
|
|
for act in paused_acts:
|
|
acts_pause.setdefault(act.patient, []).append(act)
|
|
|
|
for act in not_billable_acts:
|
|
acts_not_billable.setdefault(act.patient, []).append(act)
|
|
|
|
for act in billable_acts:
|
|
acts_billable.setdefault(act.patient, []).append(act)
|
|
return (acts_not_locked, days_not_locked, acts_not_valide,
|
|
acts_not_billable, acts_pause, acts_billable)
|
|
|
|
|
|
def list_acts_for_billing_CAMSP(start_day, end_day, service, acts=None):
|
|
"""Used to sort acts billable by specific service requirements.
|
|
|
|
For the CAMSP, only the state of the patient record 'CAMSP_STATE_SUIVI'
|
|
at the date of the act determine if the acte is billable.
|
|
|
|
acts = acts_not_locked + \
|
|
acts_not_valide + \
|
|
acts_not_billable + \
|
|
acts_bad_state + \
|
|
acts_accepted
|
|
|
|
:param end_day: formatted date that gives the last day when acts are taken
|
|
in account.
|
|
:type end_day: datetime
|
|
:param service: service in which acts are dealt with.
|
|
:type service: calebasse.ressources.Service
|
|
|
|
:returns: a list of dictionnaries where patients are the keys and values
|
|
are lists of acts. The second element of this list in not a dict but
|
|
a list of the days where are all days are not locked.
|
|
:rtype: list
|
|
"""
|
|
|
|
acts_not_locked, days_not_locked, acts_not_valide, \
|
|
acts_not_billable, acts_pause, acts_billable = \
|
|
list_acts_for_billing_first_round(end_day, service,
|
|
start_day, acts=acts)
|
|
acts_bad_state = {}
|
|
acts_accepted = {}
|
|
patients_missing_policy = []
|
|
for patient, acts in acts_billable.iteritems():
|
|
for act in acts:
|
|
if patient.was_in_state_at_day(act.date, 'SUIVI'):
|
|
acts_accepted.setdefault(act.patient, []).append(act)
|
|
else:
|
|
acts_bad_state.setdefault(act.patient, []).\
|
|
append((act, 'NOT_ACCOUNTABLE_STATE'))
|
|
for patient in acts_accepted.keys():
|
|
if not patient.policyholder or \
|
|
not patient.policyholder.health_center or \
|
|
not patient.policyholder.management_code or \
|
|
not patient.policyholder.social_security_id:
|
|
patients_missing_policy.append(patient)
|
|
return (acts_not_locked, days_not_locked, acts_not_valide,
|
|
acts_not_billable, acts_pause, acts_bad_state,
|
|
acts_accepted, patients_missing_policy)
|
|
|
|
|
|
def list_acts_for_billing_SESSAD(start_day, end_day, service, acts=None):
|
|
"""Used to sort acts billable by specific service requirements.
|
|
|
|
For the SESSAD, acts are billable if the state of the patient record at
|
|
the date of the act is 'SESSAD_STATE_TRAITEMENT' and there was also a
|
|
valid notification at that date.
|
|
|
|
acts = acts_not_locked + \
|
|
acts_not_valide + \
|
|
acts_not_billable + \
|
|
acts_bad_state + \
|
|
acts_missing_valid_notification + \
|
|
acts_accepted
|
|
|
|
:param end_day: formatted date that gives the last day when acts are taken
|
|
in account.
|
|
:type end_day: datetime
|
|
:param service: service in which acts are dealt with.
|
|
:type service: calebasse.ressources.Service
|
|
|
|
:returns: a list of dictionnaries where patients are the keys and values
|
|
are lists of acts. The second element of this list in not a dict but
|
|
a list of the days where are all days are not locked.
|
|
:rtype: list
|
|
"""
|
|
|
|
acts_not_locked, days_not_locked, acts_not_valide, \
|
|
acts_not_billable, acts_pause, acts_billable = \
|
|
list_acts_for_billing_first_round(end_day, service,
|
|
start_day=start_day, acts=acts)
|
|
acts_bad_state = {}
|
|
acts_missing_valid_notification = {}
|
|
acts_accepted = {}
|
|
patients_missing_policy = []
|
|
for patient, acts in acts_billable.iteritems():
|
|
for act in acts:
|
|
if patient.was_in_state_at_day(act.date,
|
|
'TRAITEMENT'):
|
|
if not act.was_covered_by_notification():
|
|
acts_missing_valid_notification.\
|
|
setdefault(act.patient, []).append(act)
|
|
else:
|
|
acts_accepted.setdefault(act.patient, []).append(act)
|
|
else:
|
|
acts_bad_state.setdefault(act.patient, []).\
|
|
append((act, 'NOT_ACCOUNTABLE_STATE'))
|
|
for patient in acts_accepted.keys():
|
|
if not patient.policyholder or \
|
|
not patient.policyholder.health_center or \
|
|
not patient.policyholder.management_code or \
|
|
not patient.policyholder.social_security_id:
|
|
patients_missing_policy.append(patient)
|
|
return (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)
|
|
|
|
|
|
def list_acts_for_billing_CMPP(end_day, service, acts=None):
|
|
"""Used to sort acts billable by specific service requirements.
|
|
|
|
For the CMPP, acts are billable if
|
|
|
|
acts = acts_not_locked + \
|
|
acts_not_valide + \
|
|
acts_not_billable + \
|
|
acts_diagnostic + \
|
|
acts_treatment + \
|
|
acts_losts
|
|
|
|
:param end_day: formatted date that gives the last day when acts are taken
|
|
in account.
|
|
:type end_day: datetime
|
|
:param service: service in which acts are dealt with.
|
|
:type service: calebasse.ressources.Service
|
|
|
|
:returns: a list of dictionnaries where patients are the keys and values
|
|
are lists of acts. The second element of this list in not a dict but
|
|
a list of the days where are all days are not locked.
|
|
:rtype: list
|
|
"""
|
|
|
|
acts_not_locked, days_not_locked, acts_not_valide, \
|
|
acts_not_billable, acts_pause, acts_billable = \
|
|
list_acts_for_billing_first_round(end_day, service, acts=acts)
|
|
|
|
acts_diagnostic = {}
|
|
acts_treatment = {}
|
|
acts_losts = {}
|
|
acts_losts_missing_policy = {}
|
|
acts_losts_missing_birthdate = {}
|
|
patient_ids = [p.id for p in acts_billable]
|
|
# compute latest hcds using one query
|
|
latest_hcd = {}
|
|
hcds = CmppHealthCareDiagnostic.objects.filter(patient_id__in=patient_ids).order_by('-start_date').select_related(depth=1).prefetch_related('act_set')
|
|
for hcd in hcds:
|
|
if hcd.patient not in latest_hcd:
|
|
latest_hcd[hcd.patient] = hcd
|
|
# compute two latest hcts using one query
|
|
latest_hcts = defaultdict(lambda:[])
|
|
hcts = CmppHealthCareTreatment.objects.filter(patient_id__in=patient_ids).order_by('-start_date').select_related(depth=1).prefetch_related('act_set')
|
|
for hct in hcts:
|
|
if hct.patient not in latest_hcts or len(latest_hcts[hct.patient]) < 2:
|
|
latest_hcts[hct.patient].append(hct)
|
|
|
|
for patient, acts in acts_billable.items():
|
|
if not patient.policyholder or \
|
|
not patient.policyholder.health_center or \
|
|
not patient.policyholder.social_security_id:
|
|
acts_losts_missing_policy[patient] = acts
|
|
continue
|
|
if not patient.birthdate:
|
|
acts_losts_missing_birthdate[patient] = acts
|
|
continue
|
|
# Date de début de la prise en charge ayant servis au dernier acte facturé
|
|
lasts_billed = sorted(filter(lambda a: a.is_billed and a.healthcare is not None, patient.act_set.all()), key=lambda a: a.date, reverse=True)
|
|
last_hc_date = None
|
|
if lasts_billed:
|
|
last_hc_date = lasts_billed[0].healthcare.start_date
|
|
hcd = None
|
|
len_acts_cared_diag = 0
|
|
try:
|
|
hcd = latest_hcd.get(patient)
|
|
if not last_hc_date or last_hc_date <= hcd.start_date:
|
|
# actes prise en charge par ce hc
|
|
len_acts_cared_diag = len(hcd.act_set.all())
|
|
else:
|
|
# Comme un PC diag n'a pas de date de fin, on considère qu'elle ne sert plus si un acte a été couvert par une prise en charge plus récente.
|
|
hcd = None
|
|
except:
|
|
pass
|
|
'''
|
|
We take in account the two last treatment healthcare
|
|
'''
|
|
hcts = latest_hcts.get(patient, [])
|
|
# acts are all billable and chronologically ordered
|
|
count_hcd = 0
|
|
count_hct_1 = 0
|
|
count_hct_2 = 0
|
|
for act in acts:
|
|
cared = False
|
|
# If there is overlapping between hc period the more recent must
|
|
# be used ! That should not happen with hct but might between
|
|
# hcd and hct.
|
|
if len(hcts) > 0 and hcts[0] and hcts[0].start_date <= act.date and hcts[0].end_date >= act.date:
|
|
if count_hct_2 < hcts[0].get_act_number() - hcts[0].get_nb_acts_cared():
|
|
acts_treatment.setdefault(patient, []).append((act, hcts[0]))
|
|
count_hct_2 = count_hct_2 + 1
|
|
cared = True
|
|
if not cared and len(hcts) > 1 and hcts[1] and hcts[1].start_date <= act.date and hcts[1].end_date >= act.date:
|
|
# Ce qui seraient prise en charge
|
|
# ne doit pas dépasser la limite de prise en charge du hc
|
|
if count_hct_1 < hcts[1].get_act_number() - hcts[1].get_nb_acts_cared():
|
|
acts_treatment.setdefault(patient, []).append((act, hcts[1]))
|
|
count_hct_1 = count_hct_1 + 1
|
|
cared = True
|
|
if not cared and hcd and hcd.start_date <= act.date and \
|
|
(not hcd.end_date or hcd.end_date >= act.date):
|
|
# Ce qui seraient prise en charge
|
|
nb_acts_cared = len_acts_cared_diag + count_hcd
|
|
# Ne doit pas dépasser la limite de prise en charge du hc
|
|
if nb_acts_cared < hcd.get_act_number() :
|
|
acts_diagnostic.setdefault(patient, []).append((act, hcd))
|
|
count_hcd = count_hcd + 1
|
|
cared = True
|
|
if not cared:
|
|
acts_losts.setdefault(patient, []).append(act)
|
|
return (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)
|
|
|
|
def list_acts_for_billing_CMPP_per_patient(patient, end_day, service, acts=None):
|
|
|
|
acts_not_locked, days_not_locked, acts_not_valide, \
|
|
acts_not_billable, acts_pause, acts_billable = \
|
|
list_acts_for_billing_first_round(end_day, service, acts=acts, patient=patient)
|
|
|
|
acts_per_hc = {}
|
|
acts_losts = []
|
|
if len(acts_billable.keys()) > 1:
|
|
raise "Should not find more than one patient"
|
|
elif len(acts_billable.keys()) == 1:
|
|
# Date de début de la prise en charge ayant servis au dernier acte facturé
|
|
lasts_billed = Act.objects.filter(patient=patient, is_billed = True, healthcare__isnull=False).order_by('-date')
|
|
last_hc_date = None
|
|
if lasts_billed:
|
|
last_hc_date = lasts_billed[0].healthcare.start_date
|
|
patient, acts = acts_billable.items()[0]
|
|
hcd = None
|
|
len_acts_cared_diag = 0
|
|
try:
|
|
hcd = CmppHealthCareDiagnostic.objects.\
|
|
filter(patient=patient).latest('start_date')
|
|
if not last_hc_date or last_hc_date <= hcd.start_date:
|
|
# actes prise en charge par ce hc
|
|
len_acts_cared_diag = len(hcd.act_set.all())
|
|
else:
|
|
# Comme un PC diag n'a pas de date de fin, on considère qu'elle ne sert plus si un acte a été couvert par une prise en charge plus récente.
|
|
hcd = None
|
|
except:
|
|
pass
|
|
'''
|
|
We take in account the two last treatment healthcare
|
|
'''
|
|
hcts = None
|
|
len_acts_cared_trait = 0
|
|
try:
|
|
hcts = CmppHealthCareTreatment.objects.\
|
|
filter(patient=patient).order_by('-start_date')
|
|
except:
|
|
pass
|
|
# acts are all billable and chronologically ordered
|
|
count_hcd = 0
|
|
count_hct_1 = 0
|
|
count_hct_2 = 0
|
|
if hcd:
|
|
acts_per_hc[hcd] = []
|
|
if len(hcts) > 0:
|
|
acts_per_hc[hcts[0]] = []
|
|
if len(hcts) > 1:
|
|
acts_per_hc[hcts[1]] = []
|
|
for act in acts:
|
|
cared = False
|
|
# If there is overlapping between hc period the more recent must
|
|
# be used ! That should not happen with hct but might between
|
|
# hcd and hct.
|
|
if len(hcts) > 0 and hcts[0] and hcts[0].start_date <= act.date and hcts[0].end_date >= act.date:
|
|
if count_hct_2 < hcts[0].get_act_number() - hcts[0].get_nb_acts_cared():
|
|
acts_per_hc[hcts[0]].append(act)
|
|
count_hct_2 = count_hct_2 + 1
|
|
cared = True
|
|
if not cared and len(hcts) > 1 and hcts[1] and hcts[1].start_date <= act.date and hcts[1].end_date >= act.date:
|
|
# Ce qui seraient prise en charge
|
|
# ne doit pas dépasser la limite de prise en charge du hc
|
|
if count_hct_1 < hcts[1].get_act_number() - hcts[1].get_nb_acts_cared():
|
|
acts_per_hc[hcts[1]].append(act)
|
|
count_hct_1 = count_hct_1 + 1
|
|
cared = True
|
|
if not cared and hcd and hcd.start_date <= act.date and \
|
|
(not hcd.end_date or hcd.end_date >= act.date):
|
|
# Ce qui seraient prise en charge
|
|
nb_acts_cared = len_acts_cared_diag + count_hcd
|
|
# Ne doit pas dépasser la limite de prise en charge du hc
|
|
if nb_acts_cared < hcd.get_act_number() :
|
|
acts_per_hc[hcd].append(act)
|
|
count_hcd = count_hcd + 1
|
|
cared = True
|
|
if not cared:
|
|
acts_losts.append(act)
|
|
if len(acts_pause.keys()) == 1:
|
|
acts_pause = acts_pause.values()[0]
|
|
else:
|
|
acts_pause = []
|
|
return (acts_not_locked, days_not_locked, acts_not_valide,
|
|
acts_not_billable, acts_pause, acts_per_hc, acts_losts)
|