def create_invoice(company, patient, lab_tests, prescriptions):
test_ids = json.loads(lab_tests)
line_ids = json.loads(prescriptions)
if not test_ids and not line_ids:
return
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
for line in line_ids:
test_code = frappe.get_value("Lab Prescription", line, "test_code")
create_item_line(test_code, sales_invoice)
for test in test_ids:
template = frappe.get_value("Lab Test", test, "template")
test_code = frappe.get_value("Lab Test Template", template, "item")
create_item_line(test_code, sales_invoice)
sales_invoice.set_missing_values()
sales_invoice.save()
#set invoice in lab test
for test in test_ids:
frappe.db.set_value("Lab Test", test, "invoice", sales_invoice.name)
prescription = frappe.db.get_value("Lab Test", test, "prescription")
if prescription:
frappe.db.set_value("Lab Prescription", prescription, "invoice", sales_invoice.name)
#set invoice in prescription
for line in line_ids:
frappe.db.set_value("Lab Prescription", line, "invoice", sales_invoice.name)
return sales_invoice.name
def create_invoice(company, patient, lab_tests, prescriptions):
test_ids = json.loads(lab_tests)
line_ids = json.loads(prescriptions)
if not test_ids and not line_ids:
return
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
for line in line_ids:
test_code = frappe.get_value("Lab Prescription", line, "test_code")
create_item_line(test_code, sales_invoice)
for test in test_ids:
template = frappe.get_value("Lab Test", test, "template")
test_code = frappe.get_value("Lab Test Template", template, "item")
create_item_line(test_code, sales_invoice)
sales_invoice.set_missing_values()
sales_invoice.save()
#set invoice in lab test
for test in test_ids:
frappe.db.set_value("Lab Test", test, "invoice", sales_invoice.name)
prescription = frappe.db.get_value("Lab Test", test, "prescription")
if prescription:
frappe.db.set_value("Lab Prescription", prescription, "invoice",
sales_invoice.name)
#set invoice in prescription
for line in line_ids:
frappe.db.set_value("Lab Prescription", line, "invoice",
sales_invoice.name)
return sales_invoice.name
def create_invoice(company, physician, patient, appointment_id,
appointment_date):
if not appointment_id:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.appointment = appointment_id
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
fee_validity = get_fee_validity(physician, patient, appointment_date)
create_invoice_items(appointment_id, physician, company, sales_invoice)
sales_invoice.save(ignore_permissions=True)
frappe.db.sql(
"""update `tabPatient Appointment` set sales_invoice=%s where name=%s""",
(sales_invoice.name, appointment_id))
frappe.db.set_value("Fee Validity", fee_validity.name, "ref_invoice",
sales_invoice.name)
consultation = frappe.db.exists({
"doctype": "Consultation",
"appointment": appointment_id
})
if consultation:
frappe.db.set_value("Consultation", consultation[0][0], "invoice",
sales_invoice.name)
return sales_invoice.name
def create_sales_invoice():
patient = create_patient()
medical_department = create_medical_department()
insulin_resistance_template = create_lab_test_template()
blood_test_template = create_blood_test_template(medical_department)
sales_invoice = frappe.new_doc('Sales Invoice')
sales_invoice.patient = patient
sales_invoice.customer = frappe.db.get_value('Patient', patient,
'customer')
sales_invoice.due_date = getdate()
sales_invoice.company = '_Test Company'
sales_invoice.debit_to = get_receivable_account('_Test Company')
tests = [insulin_resistance_template, blood_test_template]
for entry in tests:
sales_invoice.append(
'items', {
'item_code': entry.item,
'item_name': entry.lab_test_name,
'description': entry.lab_test_description,
'qty': 1,
'uom': 'Nos',
'conversion_factor': 1,
'income_account': get_income_account(None, '_Test Company'),
'rate': entry.lab_test_rate,
'amount': entry.lab_test_rate
})
sales_invoice.set_missing_values()
sales_invoice.submit()
return sales_invoice
def invoice_appointment(appointment_doc):
if not appointment_doc.name:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", appointment_doc.patient, "customer")
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.is_pos = True
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(appointment_doc.company)
item_line = sales_invoice.append("items")
service_item, practitioner_charge = service_item_and_practitioner_charge(appointment_doc)
item_line.item_code = service_item
item_line.description = "Consulting Charges: " + appointment_doc.practitioner
item_line.income_account = get_income_account(appointment_doc.practitioner, appointment_doc.company)
item_line.rate = practitioner_charge
item_line.amount = practitioner_charge
item_line.qty = 1
item_line.reference_dt = "Patient Appointment"
item_line.reference_dn = appointment_doc.name
payments_line = sales_invoice.append("payments")
payments_line.mode_of_payment = appointment_doc.mode_of_payment
payments_line.amount = appointment_doc.paid_amount
sales_invoice.set_missing_values(for_validate = True)
sales_invoice.save(ignore_permissions=True)
sales_invoice.submit()
frappe.msgprint(_("Sales Invoice {0} created as paid".format(sales_invoice.name)), alert=True)
def invoice_appointment(appointment_doc):
if not appointment_doc.name:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", appointment_doc.patient, "customer")
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.is_pos = True
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(appointment_doc.company)
item_line = sales_invoice.append("items")
service_item, practitioner_charge = service_item_and_practitioner_charge(appointment_doc)
item_line.item_code = service_item
item_line.description = "Consulting Charges: " + appointment_doc.practitioner
item_line.income_account = get_income_account(appointment_doc.practitioner, appointment_doc.company)
item_line.rate = practitioner_charge
item_line.amount = practitioner_charge
item_line.qty = 1
item_line.reference_dt = "Patient Appointment"
item_line.reference_dn = appointment_doc.name
payments_line = sales_invoice.append("payments")
payments_line.mode_of_payment = appointment_doc.mode_of_payment
payments_line.amount = appointment_doc.paid_amount
sales_invoice.set_missing_values(for_validate = True)
sales_invoice.save(ignore_permissions=True)
sales_invoice.submit()
frappe.msgprint(_("Sales Invoice {0} created as paid".format(sales_invoice.name)), alert=True)
def create_sales_invoice(appointment_doc):
sales_invoice = frappe.new_doc('Sales Invoice')
sales_invoice.patient = appointment_doc.patient
sales_invoice.customer = frappe.get_value('Patient', appointment_doc.patient, 'customer')
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(appointment_doc.company)
item = sales_invoice.append('items', {})
item = get_appointment_item(appointment_doc, item)
# Add payments if payment details are supplied else proceed to create invoice as Unpaid
if appointment_doc.mode_of_payment and appointment_doc.paid_amount:
sales_invoice.is_pos = 1
payment = sales_invoice.append('payments', {})
payment.mode_of_payment = appointment_doc.mode_of_payment
payment.amount = appointment_doc.paid_amount
sales_invoice.set_missing_values(for_validate=True)
sales_invoice.flags.ignore_mandatory = True
sales_invoice.save(ignore_permissions=True)
sales_invoice.submit()
frappe.msgprint(_('Sales Invoice {0} created').format(sales_invoice.name), alert=True)
frappe.db.set_value('Patient Appointment', appointment_doc.name, {
'invoiced': 1,
'ref_sales_invoice': sales_invoice.name
})
def set_missing_values(source, target):
target.customer = frappe.db.get_value('Patient', source.patient, 'customer')
target.due_date = getdate()
target.debit_to = get_receivable_account(source.company)
item = target.append('items', {})
item = get_therapy_item(source, item)
target.set_missing_values(for_validate=True)
def set_sales_invoice_fields(company, patient):
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
# patient is custom field in sales inv.
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
return sales_invoice
def set_sales_invoice_fields(company, patient):
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
# patient is custom field in sales inv.
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
return sales_invoice
def invoice_appointment(appointment_doc):
automate_invoicing = frappe.db.get_single_value(
'Healthcare Settings', 'automate_appointment_invoicing')
appointment_invoiced = frappe.db.get_value('Patient Appointment',
appointment_doc.name,
'invoiced')
enable_free_follow_ups = frappe.db.get_single_value(
'Healthcare Settings', 'enable_free_follow_ups')
if enable_free_follow_ups:
fee_validity = check_fee_validity(appointment_doc)
if fee_validity and fee_validity.status == 'Completed':
fee_validity = None
elif not fee_validity:
if frappe.db.exists('Fee Validity Reference',
{'appointment': appointment_doc.name}):
return
if check_is_new_patient(appointment_doc.patient,
appointment_doc.name):
return
else:
fee_validity = None
if automate_invoicing and not appointment_invoiced and not fee_validity:
sales_invoice = frappe.new_doc('Sales Invoice')
sales_invoice.patient = appointment_doc.patient
sales_invoice.customer = frappe.get_value('Patient',
appointment_doc.patient,
'customer')
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(
appointment_doc.company)
item = sales_invoice.append('items', {})
item = get_appointment_item(appointment_doc, item)
# Add payments if payment details are supplied else proceed to create invoice as Unpaid
if appointment_doc.mode_of_payment and appointment_doc.paid_amount:
sales_invoice.is_pos = 1
payment = sales_invoice.append('payments', {})
payment.mode_of_payment = appointment_doc.mode_of_payment
payment.amount = appointment_doc.paid_amount
sales_invoice.set_missing_values(for_validate=True)
sales_invoice.flags.ignore_mandatory = True
sales_invoice.save(ignore_permissions=True)
sales_invoice.submit()
frappe.msgprint(_('Sales Invoice {0} created'.format(
sales_invoice.name)),
alert=True)
frappe.db.set_value('Patient Appointment', appointment_doc.name,
'invoiced', 1)
frappe.db.set_value('Patient Appointment', appointment_doc.name,
'ref_sales_invoice', sales_invoice.name)
def invoice_appointment(name):
appointment_doc = frappe.get_doc("Patient Appointment", name)
automate_invoicing = frappe.db.get_single_value(
'Healthcare Settings', 'automate_appointment_invoicing')
appointment_invoiced = frappe.db.get_value(
'Patient Appointment', appointment_doc.name, 'invoiced')
if not automate_invoicing and not appointment_doc.insurance_subscription and appointment_doc.mode_of_payment and not appointment_invoiced:
sales_invoice = frappe.new_doc('Sales Invoice')
sales_invoice.patient = appointment_doc.patient
sales_invoice.customer = frappe.get_value(
'Patient', appointment_doc.patient, 'customer')
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(
appointment_doc.company)
sales_invoice.healthcare_service_unit = appointment_doc.service_unit
sales_invoice.healthcare_practitioner = appointment_doc.practitioner
item = sales_invoice.append('items', {})
item = get_appointment_item(appointment_doc, item)
item.rate = appointment_doc.paid_amount
item.amount = appointment_doc.paid_amount
# Add payments if payment details are supplied else proceed to create invoice as Unpaid
if appointment_doc.mode_of_payment and appointment_doc.paid_amount:
sales_invoice.is_pos = 1
payment = sales_invoice.append('payments', {})
payment.mode_of_payment = appointment_doc.mode_of_payment
payment.amount = appointment_doc.paid_amount
sales_invoice.set_taxes()
sales_invoice.set_missing_values(for_validate=True)
sales_invoice.flags.ignore_mandatory = True
sales_invoice.save(ignore_permissions=True)
sales_invoice.calculate_taxes_and_totals()
sales_invoice.submit()
frappe.msgprint(_('Sales Invoice {0} created'.format(
sales_invoice.name)))
appointment_doc = frappe.get_doc(
"Patient Appointment", appointment_doc.name)
appointment_doc.ref_sales_invoice = sales_invoice.name
appointment_doc.invoiced = 1
appointment_doc.db_update()
make_vital(appointment_doc, 'patient_appointment')
return "true"
def create_invoice(company, patient, physician, consultation_id):
if not consultation_id:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
create_invoice_items(physician, sales_invoice, company)
sales_invoice.save(ignore_permissions=True)
frappe.db.sql("""update tabConsultation set invoice=%s where name=%s""", (sales_invoice.name, consultation_id))
appointment = frappe.db.get_value("Consultation", consultation_id, "appointment")
if appointment:
frappe.db.set_value("Patient Appointment", appointment, "sales_invoice", sales_invoice.name)
return sales_invoice.name
def create_invoice(company, patient, physician, consultation_id):
if not consultation_id:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
create_invoice_items(physician, sales_invoice, company)
sales_invoice.save(ignore_permissions=True)
frappe.db.sql("""update tabConsultation set invoice=%s where name=%s""", (sales_invoice.name, consultation_id))
appointment = frappe.db.get_value("Consultation", consultation_id, "appointment")
if appointment:
frappe.db.set_value("Patient Appointment", appointment, "sales_invoice", sales_invoice.name)
return sales_invoice.name
def make_invoice(patient, company):
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.due_date = getdate()
sales_invoice.company = company
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
item_line = sales_invoice.append("items")
item_line.item_name = "Registeration Fee"
item_line.description = "Registeration Fee"
item_line.qty = 1
item_line.uom = "Nos"
item_line.conversion_factor = 1
item_line.income_account = get_income_account(None, company)
item_line.rate = frappe.get_value("Healthcare Settings", None, "registration_fee")
item_line.amount = item_line.rate
sales_invoice.set_missing_values()
return sales_invoice
def make_invoice(patient, company):
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.due_date = getdate()
sales_invoice.company = company
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
item_line = sales_invoice.append("items")
item_line.item_name = "Registeration Fee"
item_line.description = "Registeration Fee"
item_line.qty = 1
item_line.uom = "Nos"
item_line.conversion_factor = 1
item_line.income_account = get_income_account(None, company)
item_line.rate = frappe.get_value("Healthcare Settings", None, "registration_fee")
item_line.amount = item_line.rate
sales_invoice.set_missing_values()
return sales_invoice
def make_invoice(patient, company):
uom = frappe.db.exists('UOM', 'Nos') or frappe.db.get_single_value('Stock Settings', 'stock_uom')
sales_invoice = frappe.new_doc('Sales Invoice')
sales_invoice.customer = frappe.db.get_value('Patient', patient, 'customer')
sales_invoice.due_date = getdate()
sales_invoice.company = company
sales_invoice.is_pos = 0
sales_invoice.debit_to = get_receivable_account(company)
item_line = sales_invoice.append('items')
item_line.item_name = 'Registeration Fee'
item_line.description = 'Registeration Fee'
item_line.qty = 1
item_line.uom = uom
item_line.conversion_factor = 1
item_line.income_account = get_income_account(None, company)
item_line.rate = frappe.db.get_single_value('Healthcare Settings', 'registration_fee')
item_line.amount = item_line.rate
sales_invoice.set_missing_values()
return sales_invoice
def create_invoice(company, physician, patient, appointment_id, appointment_date):
if not appointment_id:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient", patient, "customer")
sales_invoice.appointment = appointment_id
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.debit_to = get_receivable_account(company)
fee_validity = get_fee_validity(physician, patient, appointment_date)
create_invoice_items(appointment_id, physician, company, sales_invoice)
sales_invoice.save(ignore_permissions=True)
frappe.db.sql("""update `tabPatient Appointment` set sales_invoice=%s where name=%s""", (sales_invoice.name, appointment_id))
frappe.db.set_value("Fee Validity", fee_validity.name, "ref_invoice", sales_invoice.name)
consultation = frappe.db.exists({
"doctype": "Consultation",
"appointment": appointment_id})
if consultation:
frappe.db.set_value("Consultation", consultation[0][0], "invoice", sales_invoice.name)
return sales_invoice.name
def create_sales_invoice(appointment_doc):
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.patient = appointment_doc.patient
sales_invoice.customer = frappe.get_value("Patient",
appointment_doc.patient,
"customer")
sales_invoice.currency = frappe.get_value(
"Customer", sales_invoice.customer,
"default_currency") or get_company_currency(appointment_doc.company)
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(appointment_doc.company)
item = sales_invoice.append("items", {})
item = get_appointment_item(appointment_doc, item)
# Add payments if payment details are supplied else proceed to create invoice as Unpaid
if appointment_doc.mode_of_payment and appointment_doc.paid_amount:
sales_invoice.is_pos = 1
payment = sales_invoice.append("payments", {})
payment.mode_of_payment = appointment_doc.mode_of_payment
payment.amount = appointment_doc.paid_amount
sales_invoice.set_missing_values(for_validate=True)
sales_invoice.flags.ignore_mandatory = True
sales_invoice.save(ignore_permissions=True)
sales_invoice.submit()
frappe.msgprint(_("Sales Invoice {0} created").format(sales_invoice.name),
alert=True)
frappe.db.set_value(
"Patient Appointment",
appointment_doc.name,
{
"invoiced": 1,
"ref_sales_invoice": sales_invoice.name
},
)
def invoice_appointment(appointment_doc):
if not appointment_doc.name:
return False
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.customer = frappe.get_value("Patient",
appointment_doc.patient,
"customer")
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.is_pos = '0'
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(appointment_doc.company)
fee_validity = get_fee_validity(appointment_doc.practitioner,
appointment_doc.patient,
appointment_doc.appointment_date)
procedure_template = False
if appointment_doc.procedure_template:
procedure_template = appointment_doc.procedure_template
create_invoice_items(appointment_doc.practitioner, appointment_doc.company,
sales_invoice, procedure_template)
sales_invoice.save(ignore_permissions=True)
frappe.db.sql(
"""update `tabPatient Appointment` set sales_invoice=%s where name=%s""",
(sales_invoice.name, appointment_doc.name))
frappe.db.set_value("Fee Validity", fee_validity.name, "ref_invoice",
sales_invoice.name)
encounter = frappe.db.exists({
"doctype": "Patient Encounter",
"appointment": appointment_doc.name
})
if encounter:
frappe.db.set_value("Patient Encounter", encounter[0][0], "invoice",
sales_invoice.name)
return sales_invoice.name
def create_sales_invoice():
patient = create_patient()
medical_department = create_medical_department()
insulin_resistance_template = create_lab_test_template()
blood_test_template = create_blood_test_template(medical_department)
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.patient = patient
sales_invoice.customer = frappe.db.get_value("Patient", patient,
"customer")
sales_invoice.due_date = getdate()
sales_invoice.company = "_Test Company"
sales_invoice.currency = "INR"
sales_invoice.debit_to = get_receivable_account("_Test Company")
tests = [insulin_resistance_template, blood_test_template]
for entry in tests:
sales_invoice.append(
"items",
{
"item_code": entry.item,
"item_name": entry.lab_test_name,
"description": entry.lab_test_description,
"qty": 1,
"uom": "Nos",
"conversion_factor": 1,
"income_account": get_income_account(None, "_Test Company"),
"rate": entry.lab_test_rate,
"amount": entry.lab_test_rate,
},
)
sales_invoice.set_missing_values()
sales_invoice.submit()
return sales_invoice
def invoice_appointment(name):
appointment_doc = frappe.get_doc("Patient Appointment", name)
if appointment_doc.billing_item:
if appointment_doc.mode_of_payment:
appointment_doc.paid_amount = get_mop_amount(
appointment_doc.billing_item,
appointment_doc.mode_of_payment,
appointment_doc.company,
appointment_doc.patient,
)
else:
appointment_doc.paid_amount = get_insurance_amount(
appointment_doc.insurance_subscription,
appointment_doc.billing_item,
appointment_doc.company,
appointment_doc.insurance_company,
)
appointment_doc.save()
appointment_doc.reload()
set_follow_up(appointment_doc, "invoice_appointment")
automate_invoicing = frappe.db.get_single_value(
"Healthcare Settings", "automate_appointment_invoicing")
if (not automate_invoicing and not appointment_doc.insurance_subscription
and appointment_doc.mode_of_payment
and not appointment_doc.invoiced
and not appointment_doc.ref_sales_invoice
and not appointment_doc.follow_up):
sales_invoice = frappe.new_doc("Sales Invoice")
sales_invoice.patient = appointment_doc.patient
sales_invoice.customer = frappe.get_value("Patient",
appointment_doc.patient,
"customer")
sales_invoice.appointment = appointment_doc.name
sales_invoice.due_date = getdate()
sales_invoice.company = appointment_doc.company
sales_invoice.debit_to = get_receivable_account(
appointment_doc.company)
sales_invoice.healthcare_service_unit = appointment_doc.service_unit
sales_invoice.healthcare_practitioner = appointment_doc.practitioner
item = sales_invoice.append("items", {})
item = get_appointment_item(appointment_doc, item)
item.rate = appointment_doc.paid_amount
item.amount = appointment_doc.paid_amount
# Add payments if payment details are supplied else proceed to create invoice as Unpaid
if appointment_doc.mode_of_payment and appointment_doc.paid_amount:
sales_invoice.is_pos = 1
payment = sales_invoice.append("payments", {})
payment.mode_of_payment = appointment_doc.mode_of_payment
payment.amount = appointment_doc.paid_amount
sales_invoice.set_taxes()
sales_invoice.set_missing_values(for_validate=True)
sales_invoice.flags.ignore_mandatory = True
sales_invoice.save(ignore_permissions=True)
sales_invoice.calculate_taxes_and_totals()
sales_invoice.submit()
frappe.msgprint(
_("Sales Invoice {0} created".format(sales_invoice.name)))
appointment_doc = frappe.get_doc("Patient Appointment",
appointment_doc.name)
appointment_doc.ref_sales_invoice = sales_invoice.name
appointment_doc.invoiced = 1
appointment_doc.db_update()
make_next_doc(appointment_doc, "validate")
return "true"
