def get_billable_and_total_duration(activity, start_time, end_time):
activity_duration = time_diff_in_hours(end_time, start_time)
billing_duration = 0.0
if activity.billable:
billing_duration = activity.billing_hours
if activity_duration != activity.billing_hours:
billing_duration = activity_duration * activity.billing_hours / activity.hours
return flt(activity_duration, 2), flt(billing_duration, 2)
def calculate_std_hours(self):
std_working_hours = dataent.get_value("Company", self.company,
'standard_working_hours')
for time in self.time_logs:
if time.from_time and time.to_time:
if flt(std_working_hours) > 0:
time.hours = flt(std_working_hours) * date_diff(
time.to_time, time.from_time)
else:
if not time.hours:
time.hours = time_diff_in_hours(
time.to_time, time.from_time)
def validate_time_logs(self):
self.total_completed_qty = 0.0
self.total_time_in_mins = 0.0
if self.get('time_logs'):
for d in self.get('time_logs'):
if get_datetime(d.from_time) > get_datetime(d.to_time):
dataent.throw(
_("Row {0}: From time must be less than to time").
format(d.idx))
data = self.get_overlap_for(d)
if data:
dataent.throw(
_("Row {0}: From Time and To Time of {1} is overlapping with {2}"
).format(d.idx, self.name, data.name))
if d.from_time and d.to_time:
d.time_in_mins = time_diff_in_hours(
d.to_time, d.from_time) * 60
self.total_time_in_mins += d.time_in_mins
if d.completed_qty:
self.total_completed_qty += d.completed_qty
def get_downtime(failure_date, completion_date): downtime = time_diff_in_hours(completion_date, failure_date) return round(downtime, 2)
def get_healthcare_services_to_invoice(patient):
patient = dataent.get_doc("Patient", patient)
if patient:
if patient.customer:
item_to_invoice = []
patient_appointments = dataent.get_list(
"Patient Appointment", {
'patient': patient.name,
'invoiced': False
},
order_by="appointment_date")
if patient_appointments:
fee_validity_details = []
valid_days = dataent.db.get_value("Healthcare Settings", None,
"valid_days")
max_visit = dataent.db.get_value("Healthcare Settings", None,
"max_visit")
for patient_appointment in patient_appointments:
patient_appointment_obj = dataent.get_doc(
"Patient Appointment", patient_appointment['name'])
if patient_appointment_obj.procedure_template:
if dataent.db.get_value(
"Clinical Procedure Template",
patient_appointment_obj.procedure_template,
"is_billable") == 1:
item_to_invoice.append({
'reference_type':
'Patient Appointment',
'reference_name':
patient_appointment_obj.name,
'service':
patient_appointment_obj.procedure_template
})
else:
practitioner_exist_in_list = False
skip_invoice = False
if fee_validity_details:
for validity in fee_validity_details:
if validity[
'practitioner'] == patient_appointment_obj.practitioner:
practitioner_exist_in_list = True
if validity[
'valid_till'] >= patient_appointment_obj.appointment_date:
validity[
'visits'] = validity['visits'] + 1
if int(max_visit) > validity['visits']:
skip_invoice = True
if not skip_invoice:
validity['visits'] = 1
validity[
'valid_till'] = patient_appointment_obj.appointment_date + datetime.timedelta(
days=int(valid_days))
if not practitioner_exist_in_list:
valid_till = patient_appointment_obj.appointment_date + datetime.timedelta(
days=int(valid_days))
visits = 0
validity_exist = validity_exists(
patient_appointment_obj.practitioner,
patient_appointment_obj.patient)
if validity_exist:
fee_validity = dataent.get_doc(
"Fee Validity", validity_exist[0][0])
valid_till = fee_validity.valid_till
visits = fee_validity.visited
fee_validity_details.append({
'practitioner':
patient_appointment_obj.practitioner,
'valid_till':
valid_till,
'visits':
visits
})
if not skip_invoice:
practitioner_charge = 0
income_account = None
service_item = None
if patient_appointment_obj.practitioner:
service_item, practitioner_charge = service_item_and_practitioner_charge(
patient_appointment_obj)
income_account = get_income_account(
patient_appointment_obj.practitioner,
patient_appointment_obj.company)
item_to_invoice.append({
'reference_type':
'Patient Appointment',
'reference_name':
patient_appointment_obj.name,
'service':
service_item,
'rate':
practitioner_charge,
'income_account':
income_account
})
encounters = dataent.get_list("Patient Encounter", {
'patient': patient.name,
'invoiced': False,
'docstatus': 1
})
if encounters:
for encounter in encounters:
encounter_obj = dataent.get_doc("Patient Encounter",
encounter['name'])
if not encounter_obj.appointment:
practitioner_charge = 0
income_account = None
service_item = None
if encounter_obj.practitioner:
service_item, practitioner_charge = service_item_and_practitioner_charge(
encounter_obj)
income_account = get_income_account(
encounter_obj.practitioner,
encounter_obj.company)
item_to_invoice.append({
'reference_type':
'Patient Encounter',
'reference_name':
encounter_obj.name,
'service':
service_item,
'rate':
practitioner_charge,
'income_account':
income_account
})
lab_tests = dataent.get_list("Lab Test", {
'patient': patient.name,
'invoiced': False,
'docstatus': 1
})
if lab_tests:
for lab_test in lab_tests:
lab_test_obj = dataent.get_doc("Lab Test",
lab_test['name'])
if dataent.db.get_value("Lab Test Template",
lab_test_obj.template,
"is_billable") == 1:
item_to_invoice.append({
'reference_type':
'Lab Test',
'reference_name':
lab_test_obj.name,
'service':
dataent.db.get_value("Lab Test Template",
lab_test_obj.template, "item")
})
lab_rxs = dataent.db.sql(
"""select lp.name from `tabPatient Encounter` et, `tabLab Prescription` lp
where et.patient=%s and lp.parent=et.name and lp.lab_test_created=0 and lp.invoiced=0""",
(patient.name))
if lab_rxs:
for lab_rx in lab_rxs:
rx_obj = dataent.get_doc("Lab Prescription", lab_rx[0])
if rx_obj.lab_test_code and (dataent.db.get_value(
"Lab Test Template", rx_obj.lab_test_code,
"is_billable") == 1):
item_to_invoice.append({
'reference_type':
'Lab Prescription',
'reference_name':
rx_obj.name,
'service':
dataent.db.get_value("Lab Test Template",
rx_obj.lab_test_code, "item")
})
procedures = dataent.get_list("Clinical Procedure", {
'patient': patient.name,
'invoiced': False
})
if procedures:
for procedure in procedures:
procedure_obj = dataent.get_doc("Clinical Procedure",
procedure['name'])
if not procedure_obj.appointment:
if procedure_obj.procedure_template and (
dataent.db.get_value(
"Clinical Procedure Template",
procedure_obj.procedure_template,
"is_billable") == 1):
item_to_invoice.append({
'reference_type':
'Clinical Procedure',
'reference_name':
procedure_obj.name,
'service':
dataent.db.get_value(
"Clinical Procedure Template",
procedure_obj.procedure_template, "item")
})
procedure_rxs = dataent.db.sql(
"""select pp.name from `tabPatient Encounter` et,
`tabProcedure Prescription` pp where et.patient=%s and pp.parent=et.name and
pp.procedure_created=0 and pp.invoiced=0 and pp.appointment_booked=0""",
(patient.name))
if procedure_rxs:
for procedure_rx in procedure_rxs:
rx_obj = dataent.get_doc("Procedure Prescription",
procedure_rx[0])
if dataent.db.get_value("Clinical Procedure Template",
rx_obj.procedure,
"is_billable") == 1:
item_to_invoice.append({
'reference_type':
'Procedure Prescription',
'reference_name':
rx_obj.name,
'service':
dataent.db.get_value("Clinical Procedure Template",
rx_obj.procedure, "item")
})
procedures = dataent.get_list(
"Clinical Procedure", {
'patient': patient.name,
'invoice_separately_as_consumables': True,
'consumption_invoiced': False,
'consume_stock': True,
'status': 'Completed'
})
if procedures:
service_item = get_healthcare_service_item(
'clinical_procedure_consumable_item')
if not service_item:
msg = _(("Please Configure {0} in ").format("Clinical Procedure Consumable Item") \
+ """<b><a href="#Form/Healthcare Settings">Healthcare Settings</a></b>""")
dataent.throw(msg)
for procedure in procedures:
procedure_obj = dataent.get_doc("Clinical Procedure",
procedure['name'])
item_to_invoice.append({
'reference_type':
'Clinical Procedure',
'reference_name':
procedure_obj.name,
'service':
service_item,
'rate':
procedure_obj.consumable_total_amount,
'description':
procedure_obj.consumption_details
})
inpatient_services = dataent.db.sql(
"""select io.name, io.parent from `tabInpatient Record` ip,
`tabInpatient Occupancy` io where ip.patient=%s and io.parent=ip.name and
io.left=1 and io.invoiced=0""", (patient.name))
if inpatient_services:
for inpatient_service in inpatient_services:
inpatient_occupancy = dataent.get_doc(
"Inpatient Occupancy", inpatient_service[0])
service_unit_type = dataent.get_doc(
"Healthcare Service Unit Type",
dataent.db.get_value("Healthcare Service Unit",
inpatient_occupancy.service_unit,
"service_unit_type"))
if service_unit_type and service_unit_type.is_billable == 1:
hours_occupied = time_diff_in_hours(
inpatient_occupancy.check_out,
inpatient_occupancy.check_in)
qty = 0.5
if hours_occupied > 0:
actual_qty = hours_occupied / service_unit_type.no_of_hours
floor = math.floor(actual_qty)
decimal_part = actual_qty - floor
if decimal_part > 0.5:
qty = rounded(floor + 1, 1)
elif decimal_part < 0.5 and decimal_part > 0:
qty = rounded(floor + 0.5, 1)
if qty <= 0:
qty = 0.5
item_to_invoice.append({
'reference_type':
'Inpatient Occupancy',
'reference_name':
inpatient_occupancy.name,
'service':
service_unit_type.item,
'qty':
qty
})
return item_to_invoice
else:
dataent.throw(
_("The Patient {0} do not have customer refrence to invoice").
format(patient.name))
def validate_dates(self):
for data in self.time_logs:
if data.from_time and data.to_time and time_diff_in_hours(
data.to_time, data.from_time) < 0:
dataent.throw(_("To date cannot be before from date"))