Biograph HIS

https://github.com/tacten/biograph
Admin
Biograph is an open-source hospital information system (HIS) built on Frappe and ERPNext, featuring...
Tokens:32,726
Snippets:258
Trust Score:7.7
License:GPL-3.0
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Biograph via Bench

Source: https://github.com/tacten/biograph/blob/biograph-fh/README.md

Commands to fetch the Biograph application and install it onto a specific site.

```sh
$ bench get-app https://github.com/Tacten/biograph
```

```sh
$ bench --site demo.com install-app healthcare
```

--------------------------------

### Setup Pre-commit Hooks

Source: https://github.com/tacten/biograph/blob/biograph-fh/README.md

Commands to initialize the pre-commit environment for the healthcare application.

```sh
pip install pre-commit
cd apps/healthcare
pre-commit install
npm install
pre-commit run --all-files
```

--------------------------------

### Process Task Options and Insert Document in Python

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This Python code snippet processes task options, calculates the requested start time based on time offsets, and inserts a new document into the system. It handles conditional logic for time offsets and filters out empty values before document insertion. Dependencies include the 'frappe' library and a helper function 'add_to_date'.

```python
options = {
				"mandatory": task.mandatory,
				"duration": task.task_duration,
				"task_doctype": task.task_doctype,
			}

			if task.time_offset:
				time_offset = task.time_offset if not post_event else 0 - task.time_offset
				requested_start_time = add_to_date(start_time, seconds=time_offset)
			else:
				requested_start_time = start_time

			options.update({"requested_start_time": requested_start_time})

			options = {key: value for (key, value) in options.items() if value}
			frappe.get_doc(options).insert()
```

--------------------------------

### Get Pending Invoices for Inpatient Record (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

Retrieves a dictionary of pending invoices related to an inpatient record, checking for unbilled inpatient occupancies and other document types like appointments and encounters. It aggregates pending items.

```python
def get_pending_invoices(inpatient_record):
	pending_invoices = {}
	if inpatient_record.inpatient_occupancies:
		service_unit_names = False
		for inpatient_occupancy in inpatient_record.inpatient_occupancies:
			if not inpatient_occupancy.invoiced:
				if is_service_unit_billable(inpatient_occupancy.service_unit):
					if service_unit_names:
						service_unit_names += ", " + inpatient_occupancy.service_unit
					else:
						service_unit_names = inpatient_occupancy.service_unit
		if service_unit_names:
			pending_invoices["Inpatient Occupancy"] = service_unit_names

	docs = ["Patient Appointment", "Patient Encounter", "Lab Test", "Clinical Procedure"]

	for doc in docs:
		doc_name_list = get_unbilled_inpatient_docs(doc, inpatient_record)
		if doc_name_list:
			pending_invoices = get_pending_doc(doc, doc_name_list, pending_invoices)

	return pending_invoices

def get_pending_doc(doc, doc_name_list, pending_invoices):
	if doc_name_list:
		doc_ids = False
		for doc_name in doc_name_list:
			doc_link = get_link_to_form(doc, doc_name.name)
			if doc_ids:
				doc_ids += ", " + doc_link
			else:
				doc_ids = doc_link
		if doc_ids:
			pending_invoices[doc] = doc_ids

	return pending_invoices

```

--------------------------------

### Run Insurance Test Suite

Source: https://github.com/tacten/biograph/blob/biograph-fh/wiki/insurance-parity-report.md

Executes core insurance module tests on a Frappe bench instance.

```bash
# Core insurance flows
bench --site <site> run-tests --module healthcare.healthcare.doctype.patient_insurance_coverage.test_patient_insurance_coverage
bench --site <site> run-tests --module healthcare.healthcare.doctype.insurance_claim.test_insurance_claim
bench --site <site> run-tests --module healthcare.healthcare.doctype.item_insurance_eligibility.test_item_insurance_eligibility
bench --site <site> run-tests --module healthcare.healthcare.doctype.patient_insurance_policy.test_patient_insurance_policy
bench --site <site> run-tests --module healthcare.healthcare.doctype.insurance_payor.test_insurance_payor
bench --site <site> run-tests --module healthcare.healthcare.doctype.insurance_payor_contract.test_insurance_payor_contract
```

--------------------------------

### Create Stock Entry for Medication Orders (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

Generates a new 'Stock Entry' document for issuing materials related to medication orders. It populates the stock entry with item details, quantities, and cost information, then submits it.

```python
	def make_stock_entry(self):
		stock_entry = frappe.new_doc("Stock Entry")
		stock_entry.purpose = "Material Issue"
		stock_entry.set_stock_entry_type()
		stock_entry.from_warehouse = self.warehouse
		stock_entry.company = self.company
		stock_entry.inpatient_medication_entry = self.name
		cost_center = frappe.get_cached_value("Company", self.company, "cost_center")
		expense_account = get_account(None, "expense_account", "Healthcare Settings", self.company)

		for entry in self.medication_orders:
			se_child = stock_entry.append("items")
			se_child.item_code = entry.drug_code
			se_child.item_name = entry.drug_name
			se_child.uom = frappe.db.get_value("Item", entry.drug_code, "stock_uom")
			se_child.stock_uom = se_child.uom
			se_child.qty = flt(entry.dosage)
			# in stock uom
			se_child.conversion_factor = 1
			se_child.cost_center = cost_center
			se_child.expense_account = expense_account
			# references
			se_child.patient = entry.patient
			se_child.inpatient_medication_entry_child = entry.name

		stock_entry.submit()
		return stock_entry.name

```

--------------------------------

### Nursing Task Status Updates - Python

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

Manages the status updates for Nursing Tasks. It includes validation for completing tasks, setting start and end times, and calculating task duration. It also handles notifications upon updates.

```python
	def on_update_after_submit(self):
		if self.status == "Completed" and self.task_doctype and not self.task_document_name:
			frappe.throw(_("Not Allowed to 'Complete' Nursing Task without linking Task Document"))

		if self.status == "Draft":
			frappe.throw(_("Nursing Task cannot be 'Draft' after submission"))

		if self.status == "In Progress":
			if not self.task_start_time:
				self.db_set("task_start_time", now_datetime())

		elif self.status == "Completed":
			task_end_time = now_datetime()
			self.db_set(
				{
					"task_end_time": task_end_time,
					"task_duration": time_diff_in_seconds(task_end_time, self.task_start_time),
				}
			)

		self.notify_update()
```

--------------------------------

### Constructing a Duplicate Check Filter Object

Source: https://github.com/tacten/biograph/blob/biograph-fh/wiki/PATIENT-DUPLICATE-CHECKER-USAGE-DOC.md

This JSON example illustrates how the system filters out empty fields. When a patient record is missing a value for a field like 'Mobile', the resulting filter object only contains the fields that have valid data.

```json
{
  "first_name": "John",
  "last_name": "Smith"
}
```

--------------------------------

### Configure Frappe SemGrep Rules

Source: https://github.com/tacten/biograph/blob/biograph-fh/README.md

Commands to clone and run SemGrep rules for static analysis on the codebase.

```sh
git clone --depth 1 https://github.com/frappe/semgrep-rules.git .frappe-semgrep-rules
pip install semgrep 
semgrep --vsersion (If certification error exists with latest semgrep specify version v1.123.0 and downgrade opentelemetry-api and opentelemetry-exporter-otl to v1.35.0)
semgrep ci --config ./.frappe-semgrep-rules/rules --config r/python.lang.correctness
```

--------------------------------

### Manage Nursing Task Status Updates (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This method handles updates to a nursing task after it has been submitted. It enforces rules such as requiring a linked task document for 'Completed' tasks and disallowing 'Draft' status post-submission. It also records start and end times and calculates task duration.

```python
def on_update_after_submit(self):
		if self.status == "Completed" and self.task_doctype and not self.task_document_name:
			frappe.throw(_("Not Allowed to 'Complete' Nursing Task without linking Task Document"))

		if self.status == "Draft":
			frappe.throw(_("Nursing Task cannot be 'Draft' after submission"))

		if self.status == "In Progress":
			if not self.task_start_time:
				self.db_set("task_start_time", now_datetime())

		elif self.status == "Completed":
			task_end_time = now_datetime()
			self.db_set(
				{
					"task_end_time": task_end_time,
					"task_duration": time_diff_in_seconds(task_end_time, self.task_start_time),
				}
			)

		self.notify_update()
```

--------------------------------

### Create Healthcare Service Units (Python)

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

This Python script generates multiple Healthcare Service Unit documents. It calculates the next available suffix for service unit names and inserts new documents into the database, logging any failures. Dependencies include the 'frappe' framework.

```python
capacity = cint(data.get("service_unit_capacity") or 1)

service_unit = {
	"doctype": "Healthcare Service Unit",
	"parent_healthcare_service_unit": parent if parent != company else None,
	"service_unit_type": data.get("service_unit_type") or None,
	"service_unit_capacity": capacity if capacity > 0 else 1,
	"warehouse": data.get("warehouse") or None,
	"company": company,
}

service_unit_name = "{}".format(data.get("healthcare_service_unit_name").strip(" -"))

last_suffix = frappe.db.sql(
		"""
		SELECT
		IFNULL(MAX(CAST(SUBSTRING(name FROM %(start)s FOR 4) AS UNSIGNED)), 0)
		FROM `tabHealthcare Service Unit`
		WHERE name like %(prefix)s AND company=%(company)s
		""",
		{
			"start": len(service_unit_name) + 2,
			"prefix": "{}-%".format(service_unit_name),
			"company": company,
		},
		as_list=1,
	)[0][0]
	start_suffix = cint(last_suffix) + 1

	failed_list = []
	for i in range(start_suffix, count + start_suffix):
		# name to be in the form WARD-####
		service_unit["healthcare_service_unit_name"] = "{}-{}".format(
			service_unit_name, cstr("%0*d" % (4, i))
		)
		service_unit_doc = frappe.get_doc(service_unit)
		try:
			service_unit_doc.insert()
		except Exception:
			failed_list.append(service_unit["healthcare_service_unit_name"])

	return failed_list
```

--------------------------------

### Frappe Static Data Middleware Path Resolution (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This snippet from Frappe's middleware demonstrates how it resolves file paths for static data, incorporating the site name to ensure correct directory access. It uses `os.path.join` for path construction.

```Python
site = get_site_name(frappe.app._site or self.environ.get("HTTP_HOST"))
path = os.path.join(directory, site, "public", "files", cstr(path))
```

--------------------------------

### Create Nursing Tasks from Template - Python

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

A class method to create multiple nursing tasks based on a provided template. It fetches tasks from a 'Nursing Checklist Template Task' and uses another method to create them, optionally posting an event.

```python
	@classmethod
	def create_nursing_tasks_from_template(cls, template, doc, start_time=None, post_event=True):
		tasks = frappe.get_all(
			"Nursing Checklist Template Task",
			filters={"parent": template},
			fields=["*"]
		)

		start_time = start_time or now_datetime()
		NursingTask.create_nursing_tasks(tasks, doc, start_time, post_event)
```

--------------------------------

### Create Therapy Session from Service Request

Source: https://github.com/tacten/biograph/wiki/Link-Between-Therapy-Session-and-Service-Request-of-Therapy-Plan

Handles the creation of a Therapy Session based on a Service Request. It includes checks for existing sessions and payment status, and populates the new session with relevant data from the service request.

```python
def make_therapy_session(service_request):
	if isinstance(service_request, string_types):
		service_request = json.loads(service_request)
		service_request = frappe._dict(service_request)

	if (
		frappe.db.get_single_value("Healthcare Settings", "process_service_request_only_if_paid")
		and service_request.billing_status != "Invoiced"
	):
		frappe.throw(
			_("Service Request need to be invoiced before proceeding"),
			title=_("Payment Required")
		)

	doc = frappe.new_doc("Therapy Session")
doc.therapy_type = service_request.template_dn
doc.service_request = service_request.name
doc.company = service_request.company
doc.patient = service_request.patient
doc.patient_name = service_request.patient_name
doc.gender = service_request.patient_gender
doc.patient_age = service_request.patient_age_data
doc.practitioner = service_request.practitioner
doc.department = service_request.medical_department
doc.start_date = service_request.occurrence_date
doc.start_time = service_request.occurrence_time
doc.invoiced = service_request.invoiced

	return doc
```

```javascript
		} else if (frm.doc.template_dt === 'Therapy Type') {
			frm.add_custom_button(__("Therapy Session"), function() {
				frappe.db.get_value("Therapy Session", {"service_request":frm.doc.name, "docstatus":["!=", 2]}, "name")
				.then(r => {
					if (Object.keys(r.message).length == 0) {
						frm.trigger('make_therapy_session');
					} else {
						if (r.message && r.message.name) {
							frappe.set_route("Form", "Therapy Session", r.message.name);
							frappe.show_alert({
								message: __(`Therapy Session is already created`),
								indicator: "info",
							});
						}
					}
				})
			}, __('Create'));

```

--------------------------------

### Python Frappe API Request Handling

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

Illustrates the request handling pipeline for Frappe's API endpoints. It covers routing API requests, executing commands, and building responses, including handling specific exceptions like DoesNotExistError.

```python
File "/workspace/development/frappe-bench/apps/frappe/frappe/app.py", line 114, in application
                        )
                        frappe.handler.handle()
                        response = frappe.utils.response.build_response("json")

                elif request.path.startswith("/api/"):
                        response = frappe.api.handle(request)
                        ^^^^^^^^^^^^^^^^^^^^^^^

                elif request.path.startswith("/backups"):
                        response = frappe.utils.response.download_backup(request.path)

                elif request.path.startswith("/private/files/")
File "/workspace/development/frappe-bench/apps/frappe/frappe/api/__init__.py", line 49, in handle
        try:
                endpoint, arguments = API_URL_MAP.bind_to_environ(request.environ).match()
        except NotFound:  # Wrap 404 - backward compatiblity
                raise frappe.DoesNotExistError

        data = endpoint(**arguments)
        ^^^^^^^^^^^^^^^^^^^^^
        if isinstance(data, Response):
                return data

        if data is not None:
                frappe.response["data"] = data
File "/workspace/development/frappe-bench/apps/frappe/frappe/api/v1.py", line 36, in handle_rpc_call
        import frappe.handler

        method = method.split("/")[0]  # for backward compatiblity

        frappe.form_dict.cmd = method
        return frappe.handler.handle()
        ^^^^^^^^^^^^^^^^^^^^^^^


def create_doc(doctype: str):
        data = get_request_form_data()
        data.pop("doctype", None)
```

--------------------------------

### Create Nursing Tasks from Template (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This class method facilitates the creation of nursing tasks based on a predefined template. It retrieves tasks from a 'Nursing Checklist Template Task', determines the relevant service unit and medical department, and then calls another method to create the actual 'Nursing Task' documents.

```python
@classmethod
def create_nursing_tasks_from_template(cls, template, doc, start_time=None, post_event=True):
		tasks = frappe.get_all(
			"Nursing Checklist Template Task",
			filters={"parent": template},
			fields=["*"],
		)

		start_time = start_time or now_datetime()
		NursingTask.create_nursing_tasks(tasks, doc, start_time, post_event)

	@classmethod
def create_nursing_tasks(cls, tasks, doc, start_time, post_event=True):
		for task in tasks:
			medical_department = (
				doc.get("department") if doc.get("department") else doc.get("medical_department")
			)
			if doc.get("doctype") == "Inpatient Record":
				service_unit = (
					frappe.db.get_value("Inpatient Occupancy", {"parent": doc.name, "left": 0}, "service_unit"),
				)
			else:
				service_unit = (
					doc.get("service_unit") if doc.get("service_unit") else doc.get("healthcare_service_unit")
				)

			options = {
				"doctype": "Nursing Task",
				"status": "Requested",
				"company": doc.get("company", get_default_company()),
				"service_unit": service_unit,
				"medical_department": medical_department,
				"reference_doctype": doc.get("doctype"),
				"reference_name": doc.get("name"),
				"patient": doc.get("patient"),
				"activity": task.activity,
			
```

--------------------------------

### Admit Patient to Inpatient Record (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

Handles patient admission by setting admission datetime, status to 'Admitted', and expected discharge date. It also initializes inpatient occupancies and transfers the patient to a service unit.

```python
def admit_patient(inpatient_record, service_unit, check_in, expected_discharge=None):
	validate_nursing_tasks(inpatient_record)

	inpatient_record.admitted_datetime = check_in
	inpatient_record.status = "Admitted"
	inpatient_record.expected_discharge = expected_discharge

	inpatient_record.set("inpatient_occupancies", [])

transfer_patient(inpatient_record, service_unit, check_in)

	frappe.db.set_value(
		"Patient",
		inpatient_record.patient,
		{"inpatient_status": "Admitted", "inpatient_record": inpatient_record.name},
	)


```

--------------------------------

### Python Frappe Command Execution

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

Details the process of executing commands within the Frappe framework. This includes validating whitelisted methods, checking HTTP method compatibility, and ultimately calling the specified function with provided arguments.

```python
File "/workspace/development/frappe-bench/apps/frappe/frappe/handler.py", line 50, in handle

        cmd = frappe.local.form_dict.cmd
        data = None

        if cmd != "login":
                data = execute_cmd(cmd)
                ^^^^^^^^^^^^

        # data can be an empty string or list which are valid responses
        if data is not None:
                if isinstance(data, Response):
                        # method returns a response object, pass it on
File "/workspace/development/frappe-bench/apps/frappe/frappe/handler.py", line 86, in execute_cmd

        if method != run_doc_method:
                is_whitelisted(method)
                is_valid_http_method(method)

        return frappe.call(method, **frappe.form_dict)
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^


def run_server_script(server_script):

```

--------------------------------

### Handle Incoming WSGI Application Request - Python

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This code snippet demonstrates how a WSGI application handles incoming requests within the Werkzeug framework. It wraps the application call in a 'ClosingIterator' to ensure cleanup tasks like rate limiting, recorder dumping, and session destruction are performed. It also catches HTTP exceptions and returns appropriate responses.

```python
def application(environ, start_response):
        return ClosingIterator(
                app(environ, start_response),
                (
                        frappe.rate_limiter.update,
                        frappe.recorder.dump,
                        frappe.request.after_response.run,
                        frappe.destroy,
                )
        )
```

--------------------------------

### Create Service Requests for Healthcare Documents (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This function iterates through lab tests, clinical procedures, and therapies, creating service requests if they don't already exist. It fetches relevant templates, retrieves order details, and submits the orders, linking them back to the original document.

```python
template = "observation_template"
				elif lab_test.lab_test_code:
					template_doc = "Lab Test Template"
					template = "lab_test_code"
				else:
					continue
				if not lab_test.service_request:
					lab_template = frappe.get_doc(template_doc, lab_test.get(template))
					order = self.get_order_details(lab_template, lab_test)
					order.insert(ignore_permissions=True, ignore_mandatory=True)
					order.submit()
					lab_test.service_request = order.name

		if self.procedure_prescription:
			for procedure in self.procedure_prescription:
				if not procedure.service_request:
					procedure_template = frappe.get_doc("Clinical Procedure Template", procedure.procedure)
					order = self.get_order_details(procedure_template, procedure)
					order.insert(ignore_permissions=True, ignore_mandatory=True)
					order.submit()
					procedure.service_request = order.name

		if self.therapies:
			for therapy in self.therapies:
				if not therapy.service_request:
					therapy_type = frappe.get_doc("Therapy Type", therapy.therapy_type)
					order = self.get_order_details(therapy_type, therapy)
					order.insert(ignore_permissions=True, ignore_mandatory=True)
					order.submit()
					therapy.service_request = order.name
```

--------------------------------

### Frappe Message Printing and Real-time Updates (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This snippet details how messages are handled in Frappe, including appending them to a log or publishing them in real-time if the `realtime` flag is set. It also includes a call to `_raise_exception`.

```Python
if realtime:
                publish_realtime(event="msgprint", message=out)
        else:
                message_log.append(out)
        _raise_exception()
```

--------------------------------

### Process Stock Entry for Inpatient Medication (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

Handles the creation and submission of a stock entry for inpatient medication. It validates medication orders, updates stock if necessary, and generates success messages.

```python
	def on_submit(self):
		self.validate_medication_orders()
		success_msg = ""
		if self.update_stock:
			stock_entry = self.process_stock()
			success_msg += _("Stock Entry {0} created and ").format(
				frappe.bold(get_link_to_form("Stock Entry", stock_entry))
			)

		self.update_medication_orders()
		success_msg += _("Inpatient Medication Orders updated successfully")
		frappe.msgprint(success_msg, title=_("Success"), indicator="green")

```

--------------------------------

### Admit Patient Dialog Implementation

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This JavaScript function creates a modal dialog for admitting patients. It handles input fields for service units and dates, and triggers a server-side method call to process the admission.

```javascript
let admit_patient_dialog = function(frm) {
	let dialog = new frappe.ui.Dialog({
		title: 'Admit Patient',
		width: 100,
		fields: [
			{fieldtype: 'Link', label: 'Service Unit Type', fieldname: 'service_unit_type',
				options: 'Healthcare Service Unit Type', default: frm.doc.admission_service_unit_type
			},
			{fieldtype: 'Link', label: 'Service Unit', fieldname: 'service_unit',
				options: 'Healthcare Service Unit', reqd: 1
			},
			{fieldtype: 'Datetime', label: 'Admission Datetime', fieldname: 'check_in',
				reqd: 1, default: frappe.datetime.now_datetime()
			},
			{fieldtype: 'Date', label: 'Expected Discharge', fieldname: 'expected_discharge',
				default: frm.doc.expected_length_of_stay ? frappe.datetime.add_days(frappe.datetime.now_datetime(), frm.doc.expected_length_of_stay) : ''
			}
		],
		primary_action_label: __('Admit'),
		primary_action : function(){
			let service_unit = dialog.get_value('service_unit');
			let check_in = dialog.get_value('check_in');
			let expected_discharge = null;
			if (dialog.get_value('expected_discharge')) {
				expected_discharge = dialog.get_value('expected_discharge');
			}
			if (!service_unit && !check_in) {
				return;
			}
			frappe.call({
				doc: frm.doc,
				method: 'admit',
				args:{
					'service_unit': service_unit,
					'check_in': check_in,
					'expected_discharge': expected_discharge
				},
				callback: function(data) {
					if (!data.exc) {
						frm.reload_doc();
					}
				},
				freeze: true,
				freeze_message: __('Processing Patient Admission')
			});
			frm.refresh_fields();
			dialog.hide();
		}
	});
	dialog.show();
};
```

--------------------------------

### Python Safe Evaluation with Frappe

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

Demonstrates Frappe's implementation of a safer evaluation mechanism for Python code, preventing execution of unsafe operations. It utilizes a restricted compilation policy and whitelists specific built-ins.

```python
def safe_eval(code, eval_globals=None, eval_locals=None):
        """A safer `eval`"""

        from frappe.utils.safe_exec import safe_eval

        return safe_eval(code, eval_globals, eval_locals)

def get_website_settings(key):
        if not hasattr(local, "website_settings"):
                try:
File "/workspace/development/frappe-bench/apps/frappe/frappe/utils/safe_exec.py", line 136, in safe_eval
                eval_globals = {}

        eval_globals["__builtins__"] = {}
        eval_globals.update(WHITELISTED_SAFE_EVAL_GLOBALS)

        return eval(
        
                compile_restricted(code, filename="<safe_eval>", policy=FrappeTransformer, mode="eval"),
                eval_globals,
                eval_locals,
        )

File "<safe_eval>", line 1, in <module>
File "/workspace/development/frappe-bench/apps/frappe/frappe/utils/safe_exec.py", line 537, in _get_attr_for_eval
def _get_attr_for_eval(object, name, default=ARGUMENT_NOT_SET):
        _validate_attribute_read(object, name)

        # Use vanilla getattr to raise correct attribute error. Safe exec has been supressing attribute
        # error which is bad for DX/UX in general.
        return getattr(object, name) if default is ARGUMENT_NOT_SET else getattr(object, name, default)
        ^^^^^^^^^^^^^^^^^^^^^


def _validate_attribute_read(object, name):
        if isinstance(name, str) and (name in UNSAFE_ATTRIBUTES):
                raise SyntaxError(f"{name} is an unsafe attribute")
```

--------------------------------

### Frappe Notification Evaluation Logic (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This code demonstrates the logic for evaluating alerts and notifications within the Frappe framework. It checks if a notification has already been executed and evaluates it based on the event type and method name.

```Python
def _evaluate_alert(alert):
        if alert.name in self.flags.notifications_executed:
                return

        evaluate_alert(self, alert.name, alert.event)
        self.flags.notifications_executed.append(alert.name)

event_map = {
        "on_update": "Save",
        "after_insert": "New",
}
```

--------------------------------

### Configure Healthcare Service Unit Properties - Python

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

Sets properties for a Healthcare Service Unit based on whether it's a group or a specific type. It configures appointment settings, occupancy, and capacity, fetching details from 'Healthcare Service Unit Type' if applicable.

```python
	sdef set_service_unit_properties(self):
		if cint(self.is_group):
			self.allow_appointments = False
			self.overlap_appointments = False
			self.inpatient_occupancy = False
			self.service_unit_capacity = 0
			self.occupancy_status = ""
			self.service_unit_type = ""
		elif self.service_unit_type != "":
			service_unit_type = frappe.get_doc("Healthcare Service Unit Type", self.service_unit_type)
			self.allow_appointments = service_unit_type.allow_appointments
			self.inpatient_occupancy = service_unit_type.inpatient_occupancy

			if self.inpatient_occupancy and self.occupancy_status != "":
				self.occupancy_status = "Vacant"

			if service_unit_type.overlap_appointments:
				self.overlap_appointments = True
			else:
				self.overlap_appointments = False
				self.service_unit_capacity = 0
```

--------------------------------

### Create Inpatient Record from Order

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This Python function initializes a new Inpatient Record document based on an admission order. It maps patient details and clinical encounter data such as symptoms, diagnoses, and prescriptions to the new record.

```python
def create_inpatient_record(admission_order):
	if isinstance(admission_order, str):
		admission_order = json.loads(admission_order)
	if not admission_order or not admission_order["patient"] or not admission_order["admission_encounter"]:
		frappe.throw(_("Missing required details, did not create Inpatient Record"))
	inpatient_record = frappe.new_doc("Inpatient Record")
	set_details_from_ip_order(inpatient_record, admission_order)
	patient = frappe.get_doc("Patient", admission_order["patient"])
	inpatient_record.patient = patient.name
	inpatient_record.patient_name = patient.patient_name
	inpatient_record.gender = patient.sex
	inpatient_record.blood_group = patient.blood_group
	inpatient_record.dob = patient.dob
	inpatient_record.mobile = patient.mobile
	inpatient_record.email = patient.email
	inpatient_record.phone = patient.phone
	inpatient_record.scheduled_date = today()
	encounter = frappe.get_doc("Patient Encounter", admission_order["admission_encounter"])
	if encounter and encounter.symptoms:
		set_ip_child_records(inpatient_record, "chief_complaint", encounter.symptoms)
	if encounter and encounter.diagnosis:
		set_ip_child_records(inpatient_record, "diagnosis", encounter.diagnosis)
	if encounter and encounter.drug_prescription:
		set_ip_child_records(inpatient_record, "drug_prescription", encounter.drug_prescription)
	if encounter and encounter.lab_test_prescription:
		set_ip_child_records(inpatient_record, "lab_test_prescription", encounter.lab_test_prescription)
	if encounter and encounter.procedure_prescription:
		set_ip_child_records(inpatient_record, "procedure_prescription", encounter.procedure_prescription)
	if encounter and encounter.therapies:
		inpatient_record.therapy_plan = encounter.therapy_plan
		set_ip_child_records(inpatient_record, "therapies", encounter.therapies)
	inpatient_record.status = "Admission Scheduled"
```

--------------------------------

### Schedule Inpatient Record Creation (Python)

Source: https://github.com/tacten/biograph/wiki/The-inpatient-flow

Python function 'schedule_inpatient' that creates a new 'Inpatient Record' document. It parses admission order details from the provided arguments, validates required fields, and populates the new record with patient information and admission details.

```python
def schedule_inpatient(args):
	admission_order = json.loads(args)  # admission order via Encounter
	if (
		not admission_order
		or not admission_order["patient"]
		or not admission_order["admission_encounter"]
	):
		frappe.throw(_("Missing required details, did not create Inpatient Record"))

	inpatient_record = frappe.new_doc("Inpatient Record")

	# Admission order details
	set_details_from_ip_order(inpatient_record, admission_order)

	# Patient details
	patient = frappe.get_doc("Patient", admission_order["patient"])
	inpatient_record.patient = patient.name
	inpatient_record.patient_name = patient.patient_name
	inpatient_record.gender = patient.sex
	inpatient_record.blood_group = patient.blood_group
	inpatient_record.dob = patient.dob
	inpatient_record.mobile = patient.mobile
	inpatient_record.email = patient.email
	inpatient_record.phone = patient.phone

```

--------------------------------

### Define Workspace Shortcuts and Filters

Source: https://github.com/tacten/biograph/wiki/Insurance-Module-Functional-Coverage

Configures shortcut links for the workspace, including specific stats filters for DocTypes like Insurance Claim and Sales Invoice. These filters determine which records appear in the dashboard views.

```json
{
 "shortcuts": [
  {
   "label": "Insurance Claim",
   "link_to": "Insurance Claim",
   "stats_filter": "[[\"Insurance Claim\",\"status\",\"in\",[\"Draft\",\"Submitted\",null]],[\"Insurance Claim\",\"docstatus\",\"=\",\"1\"]]",
   "type": "DocType"
  }
 ]
}
```

--------------------------------

### Handle Post-Insert Inpatient Record Logic

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

The after_insert method updates the patient status, links medication and service requests associated with the admission encounter, and initializes nursing tasks from a template.

```python
def after_insert(self):
	frappe.db.set_value("Patient", self.patient, "inpatient_record", self.name)
	frappe.db.set_value("Patient", self.patient, "inpatient_status", self.status)

	if self.admission_encounter:
		frappe.db.set_value(
			"Patient Encounter",
			self.admission_encounter,
			{"inpatient_record": self.name, "inpatient_status": self.status},
		)

		filters = {"order_group": self.admission_encounter, "docstatus": 1}
		medication_requests = frappe.get_all("Medication Request", filters, ["name"])
		service_requests = frappe.get_all("Service Request", filters, ["name"])

		for service_request in service_requests:
			frappe.db.set_value(
				"Service Request",
				service_request.name,
				{"inpatient_record": self.name, "inpatient_status": self.status},
			)

		for medication_request in medication_requests:
			frappe.db.set_value(
				"Medication Request",
				medication_request.name,
				{"inpatient_record": self.name, "inpatient_status": self.status},
			)

	if self.admission_nursing_checklist_template:
		NursingTask.create_nursing_tasks_from_template(
			template=self.admission_nursing_checklist_template,
			doc=self,
		)
```

--------------------------------

### Configure Service Unit Query (JavaScript)

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

This JavaScript code configures the query for the 'service_unit' field in a frontend dialog. It sets filters based on company, service unit type, and occupancy status, ensuring only relevant and vacant service units are displayed. This is typically used within a Frappe framework application.

```javascript
dialog.fields_dict['service_unit'].get_query = function() {
		return {
			filters: {
				'is_group': 0,
				'company': frm.doc.company,
				'service_unit_type': dialog.get_value('service_unit_type'),
				'occupancy_status' : 'Vacant'
			}
		};
	};
```

--------------------------------

### Create Service Request from Lab Test Prescription (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

Initiates the creation of a service request based on a lab test prescription within a patient encounter. It iterates through lab tests and checks for associated observation templates.

```python
	def make_service_request(self):
		if self.lab_test_prescription:
			for lab_test in self.lab_test_prescription:
				if lab_test.observation_template:
					template_doc = "Observation Template"

```

--------------------------------

### Werkzeug Shared Data Middleware File Handling (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This code is part of the Werkzeug library's Shared Data Middleware. It shows the logic for determining whether to serve a file directly or pass the request to the underlying application, based on file existence and permissions.

```Python
if file_loader is None or not self.is_allowed(real_filename):  # type: ignore
            return self.app(environ, start_response)

        guessed_type = mimetypes.guess_type(real_filename)  # type: ignore
```

--------------------------------

### Healthcare Service Unit Initialization - Python

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

Initializes a Healthcare Service Unit. It sets the parent field for nested set model and loads address and contact information on load. It also validates service unit properties.

```python
class HealthcareServiceUnit(NestedSet):
	nsm_parent_field = "parent_healthcare_service_unit"

	sdef onload(self):
		"""Load address and contacts in `__onload`"""
		load_address_and_contact(self)

	sdef validate(self):
		self.set_service_unit_properties()
```

--------------------------------

### Frappe Error Handling and Logging in Notifications (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This snippet illustrates how Frappe handles exceptions during notification evaluation. It logs the error, formats a detailed message including the traceback, and then throws a user-friendly exception.

```Python
except Exception as e:
        title = str(e)
        message = frappe.get_traceback(with_context=True)
        frappe.log_error(title=title, message=message)
        msg = f"<details><summary>{title}</summary>{message}</details>"
        frappe.throw(msg, title=_("Error in Notification"))
```

--------------------------------

### Handle Exceptions in Frappe Application - Python

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This snippet shows Frappe's exception handling mechanism within its WSGI application. It differentiates between HTTP exceptions and general exceptions, calling 'handle_exception' for the latter. It also includes logic for rolling back database transactions.

```python
except HTTPException as e:
                return e

        except Exception as e:
                response = handle_exception(e)

        else:
                rollback = sync_database(rollback)

        finally:
```

--------------------------------

### Frappe Document Hook Execution and Notification Triggering (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This snippet shows the execution of a document hook, which involves calling a method, running associated notifications, and returning the output. It highlights the flow of control after a method is invoked on a document object.

```Python
fn.__name__ = str(method)
out = Document.hook(fn)(self, *args, **kwargs)

self.run_notifications(method)
run_webhooks(self, method)
run_server_script_for_doc_event(self, method)

return out
```

--------------------------------

### Define Order Request Styles

Source: https://github.com/tacten/biograph/blob/biograph-fh/healthcare/public/js/healthcare_orders.html

CSS styles for the service and medication request containers, defining layout, padding, and border properties for consistent UI rendering.

```CSS
.orders { min-height: 50px; padding-left: 0px; padding-bottom: 15px !important; } .service-request, .medication-request { min-height: 90px; border: 1px solid var(--border-color); padding-right: 0; font-size: 11px; padding-left: 5px; padding-top: 10px; } .no-orders { text-align: center; padding: 30px; }
```

--------------------------------

### Check Out Inpatient Occupancy

Source: https://github.com/tacten/biograph/wiki/Patient-Inpatient-Admission-Flow

Iterates through inpatient occupancies and marks them as left with the current timestamp if they are not already marked.

```python
def check_out_inpatient(inpatient_record):
	if inpatient_record.inpatient_occupancies:
		for inpatient_occupancy in inpatient_record.inpatient_occupancies:
			if inpatient_occupancy.left != 1:
				inpatient_occupancy.left = True
				inpatient_occupancy.check_out = now_datetime()
```

--------------------------------

### Manage Document Lifecycle States

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

Methods for handling document state transitions. These functions update the docstatus to submitted or cancelled and trigger the save process.

```python
def submit(self):
	"""Submit the document. Sets `docstatus` = 1, then saves."""
	return self._submit()

def cancel(self):
	"""Cancel the document. Sets `docstatus` = 2, then saves."""
	return self._cancel()

def _submit(self):
	self.docstatus = DocStatus.submitted()
	return self.save()

def _cancel(self):
	self.docstatus = DocStatus.cancelled()
	return self.save()
```

--------------------------------

### Handle Post-Save Lifecycle Hooks

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

Executes specific methods based on the document action performed, such as on_update, on_submit, or on_cancel.

```python
def run_post_save_methods(self):
	if self._action == "save":
		self.run_method("on_update")
	elif self._action == "submit":
		self.run_method("on_update")
		self.run_method("on_submit")
	elif self._action == "cancel":
		self.run_method("on_cancel")
```

--------------------------------

### Re-index Biograph Repositories

Source: https://github.com/tacten/biograph/blob/biograph-fh/wiki/insurance-parity-report.md

Runs gitnexus analysis on the specified insurance-related directories.

```bash
cd biograph-fh/biograph-fh && gitnexus analyze
cd biograph-insurance-v15 && gitnexus analyze
```

--------------------------------

### Set Healthcare Service Unit Properties in Python

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This Python code sets properties for a healthcare service unit based on whether it's a group or has a specific service unit type. It configures appointment allowances, occupancy settings, and capacity. It also includes validation to ensure a capacity is set when overlapping appointments are enabled. Dependencies include the 'frappe' library and helper functions like 'cint' and '_'.

```python
	def set_service_unit_properties(self):
		if cint(self.is_group):
			self.allow_appointments = False
			self.overlap_appointments = False
			self.inpatient_occupancy = False
			self.service_unit_capacity = 0
			self.occupancy_status = ""
			self.service_unit_type = ""
		elif self.service_unit_type != "":
			service_unit_type = frappe.get_doc("Healthcare Service Unit Type", self.service_unit_type)
			self.allow_appointments = service_unit_type.allow_appointments
			self.inpatient_occupancy = service_unit_type.inpatient_occupancy

			if self.inpatient_occupancy and self.occupancy_status != "":
				self.occupancy_status = "Vacant"

			if service_unit_type.overlap_appointments:
				self.overlap_appointments = True
			else:
				self.overlap_appointments = False
				self.service_unit_capacity = 0

		if self.overlap_appointments:
			if not self.service_unit_capacity:
				frappe.throw(
					_("Please set a valid Service Unit Capacity to enable Overlapping Appointments"),
					title=_("Mandatory"),
				)

```

--------------------------------

### Manage Inpatient Lifecycle Functions

Source: https://github.com/tacten/biograph/wiki/The-inpatient-flow

Core backend functions for handling patient admission, status updates, and discharge. These functions ensure data consistency across patient demographics, service unit occupancy, and clinical records.

```python
def schedule_inpatient(patient_id, encounter_id):
    # Logic to copy demographics and encounter data
    # Sets status to 'Admission Scheduled'
    pass

def admit_patient(inpatient_id):
    # Records admission datetime and updates service unit occupancy
    pass

def discharge_patient(inpatient_id):
    # Validates nursing tasks, invoices, and service requests
    # Finalizes discharge and updates patient status
    pass
```

--------------------------------

### Fetch and Set Insurance Coverages

Source: https://github.com/tacten/biograph/wiki/Insurance-Module-Functional-Coverage

JavaScript functions to fetch insurance coverages based on provided details (payor, dates, policy) and then set totals. It uses Frappe's client-side API for asynchronous calls and UI updates.

```javascript
	fetch_coverages_based_on: function (frm) {
			frm.trigger("get_insurance_coverages");
	},

	get_insurance_coverages: function (frm) {
			if (
				frm.doc.insurance_payor &&
				frm.doc.from_date &&
				frm.doc.to_date &&
				frm.doc.insurance_policy
			) {
				frm.clear_table("coverages");

				frappe.call({
					method: "get_coverages",
					doc: frm.doc,
					freeze: true,
					freeze_message: __("Fetching Coverages"),
					callback: function () {
						frm.refresh_field("coverages");
						frm.trigger("set_totals");
					},
				});
			}
		}
```

--------------------------------

### Create Medication Request from Drug Prescription (Python)

Source: https://github.com/tacten/biograph/wiki/In‐Patient-Management-Workflows:-Gaps-and-Areas-for-Enhancements

This function processes drug prescriptions to create medication requests. It checks if a medication or drug code exists and if a medication request has already been created. If not, it fetches medication details, creates an order, submits it, and records the new medication request name.

```python
def make_medication_request(self):
		if self.drug_prescription:
			# make_medication_request
			for drug in self.drug_prescription:
				if (drug.medication or drug.drug_code) and not drug.medication_request:
					medication = ""
					if drug.medication:
						medication = frappe.get_doc("Medication", drug.medication)
					order = self.get_order_details(medication, drug, True)
					order.insert(ignore_permissions=True, ignore_mandatory=True)
					order.submit()
					drug.medication_request = order.name
```

--------------------------------

### Evaluate Patient Encounter Referral Status (Python)

Source: https://github.com/tacten/biograph/wiki/Error-on-submit

This snippet demonstrates the use of Frappe's safe_eval to check if a PatientEncounter has a referring practitioner and if its referral status is 'New Referral'. It highlights the context provided to safe_eval, including the 'doc' object and utility functions.

```Python
code = "doc.referring_practitioner and doc.referral_status == 'New Referral'"
eval_locals = {
    'doc': <PatientEncounter: HLC-ENC-2025-00055 docstatus=1>,
    'nowdate': <function nowdate at 0x7f596b4c27a0>,
    'frappe': frappe(utils={
        'DATE_FORMAT': '%Y-%m-%d',
        'TIME_FORMAT': '%H:%M:%S.%f',
        'DATETIME_FORMAT': '%Y-%m-%d %H:%M:%S.%f',
        'is_invalid_date_string': <function is_invalid_date_string at 0x7f596b4c16c0>,
        'getdate': <function getdate at 0x7f596b4c1800>,
        'get_datetime': <function get_datetime at 0x7f596b4c1760>,
        'get_timedelta': <function get_timedelta at 0x7f596b4c18a0>,
        'to_timedelta': <function to_timedelta at 0x7f596b4c1940>,
        'add_to_date': <function add_to_date at 0x7f596b4c1c60>,
        'add_days': <function add_days at 0x7f596b4c1d00>,
        'add_months': <function add_months at 0x7f596b4c1da0>,
        'add_years': <function add_years at 0x7f596b4c1e40>,
        'date_diff': <function date_diff at 0x7f596b4c1ee0>,
        'month_diff': <function month_diff at 0x7f596b4c2020>,
        'time_diff': <function time_diff at 0x7f596b4c20c0>,
        'time_diff_in_seconds': <function time_diff_in_seconds at 0x7f596b4c2160>
    })
}
safe_eval(code, eval_globals=None, eval_locals=eval_locals)
```

--------------------------------

### Render Observation Data Fields

Source: https://github.com/tacten/biograph/blob/biograph-fh/healthcare/healthcare/doctype/observation/observation.html

This snippet demonstrates conditional rendering of observation attributes such as sample details, formatted timestamps, and result values. It utilizes Frappe framework methods like db.get_value and format_datetime to fetch and display data dynamically.

```Jinja2
{% if comps.get("observation").get("received_time") %}
  {{frappe.utils.format_datetime(comps.get("observation").get("received_time"))[:-3]}}
{% endif %}

{% if comps.get("observation").get("result_data") or comps.get("observation").get("result_select") %}
  {{comps.get("observation").get("result_data") or comps.get("observation").get("result_select")}}
{% endif %}
```

--------------------------------

### Therapy Plan Detail Field Configuration

Source: https://github.com/tacten/biograph/wiki/Link-Between-Therapy-Session-and-Service-Request-of-Therapy-Plan

JSON configuration for a field named 'service_request' within the 'Therapy Plan Detail' doctype. This field is of type 'Data', read-only, and not copied.

```json
	  "allow_on_submit": 1,
	  "fieldname": "service_request",
	  "fieldtype": "Data",
	  "label": "Service Request",
	  "no_copy": 1,
	  "read_only": 1
	 },
```
Tokens:
Raw