def __treatment_view_post(request, encounter):
treatment_form = TreatmentForm(request.POST)
if treatment_form.is_valid():
treatment = treatment_form.save(commit=False)
treatment.encounter = encounter
treatment.prescriber = request.user
if treatment.administration_schedule is not None:
treatment.amount = (treatment.days *
treatment.administration_schedule.modifier)
else:
treatment.amount = 1
treatment.save()
treatment_form.save_m2m()
for item in treatment.medication.all().iterator():
item.amount -= treatment.amount
if item.count > 0:
item.quantity = math.ceil(item.amount / item.count)
else:
item.quantity = item.amount
item.save()
treatment_form = TreatmentForm()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
return treatment_form
def new_diagnosis_view_post(request, encounter, diagnosis_set):
if len(diagnosis_set) > 0:
diagnosis_form = PatientDiagnosisForm(request.POST,
instance=diagnosis_set[0])
else:
diagnosis_form = PatientDiagnosisForm(request.POST)
if diagnosis_form.is_valid():
if len(diagnosis_set) > 1:
PatientDiagnosis.objects.exclude(pk=diagnosis_set[0].id).delete()
diagnosis = diagnosis_form.save(commit=False)
diagnosis.encounter = encounter
diagnosis.save()
diagnosis_form.save_m2m()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
return diagnosis_form
def __login_view_post_failure(request):
ip_address = get_client_ip(request)
AuditEntry.objects.create(
action="user_login_failed",
ip=ip_address,
username=request.POST["username"],
)
if "username" in request.COOKIES:
form = LoginForm(initial={"username": request.COOKIES["username"]})
else:
form = LoginForm()
try:
user = fEMRUser.objects.get(username=request.POST["username"])
if user.is_active:
error_message = "Invalid username or password."
else:
error_message = (
"Your account has been locked. Please contact your administrator."
)
except fEMRUser.DoesNotExist:
error_message = "Invalid username or password."
return render(
request,
"auth/login.html",
{
"error_message": error_message,
"form": form
},
)
def submit_hpi_view(request, patient_id=None, encounter_id=None, hpi_id=None):
if request.user.is_authenticated:
if request.user.current_campaign == "RECOVERY MODE":
return_response = redirect("main:home")
elif request.method == "POST":
encounter = get_object_or_404(PatientEncounter, pk=encounter_id)
history = HistoryOfPresentIllness.objects.get(pk=hpi_id)
aux_form = HistoryOfPresentIllnessForm(request.POST,
instance=history)
if aux_form.is_valid():
updated_history = aux_form.save()
updated_history.save()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(
name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
return_response = redirect("main:hpi_view",
patient_id=patient_id,
encounter_id=encounter_id)
else:
return_response = redirect("/not_logged_in")
return return_response
def update_user_password_view(request, user_id=None):
error = ""
user = get_object_or_404(fEMRUser, pk=user_id)
if request.method == "POST":
form = AdminPasswordForm(request.POST or None, instance=user)
if form.is_valid():
item = form.save()
item.save()
user.change_password = True
user.save()
DatabaseChangeLog.objects.create(
action="Change Password",
model="User",
instance=str(item),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(
name=request.user.current_campaign),
)
return_response = render(request, "admin/user_edit_confirmed.html")
else:
error = "Form is invalid."
else:
form = AdminPasswordForm(instance=user)
return_response = render(
request,
"admin/user_password_edit_form.html",
{
"error": error,
"form": form,
"user_id": user_id,
"page_name": "Editing User Password",
},
)
return return_response
def __aux_form_is_valid(request, encounter, treatment_form):
encounter.procedure = request.POST["procedure"]
encounter.pharmacy_notes = request.POST["pharmacy_notes"]
encounter.save()
querysets = list(PatientDiagnosis.objects.filter(encounter=encounter))
if len(querysets) > 0:
item = querysets.pop().diagnosis.all()
for query_item in querysets:
item.union(query_item.diagnosis.all())
treatment_form.fields["diagnosis"].queryset = item
else:
treatment_form.fields["diagnosis"].queryset = Diagnosis.objects.none()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
return render(
request,
"data/encounter_submitted.html",
{
"patient_id": encounter.patient.id,
"encounter_id": encounter.id
},
)
def __encounter_edit_form_get(request, patient_id, encounter_id):
encounter = get_object_or_404(PatientEncounter, pk=encounter_id)
patient = get_object_or_404(Patient, pk=patient_id)
units = Campaign.objects.get(name=request.user.current_campaign).units
vitals_form = VitalsForm(unit=units)
DatabaseChangeLog.objects.create(
action="View",
model="Patient",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
form = PatientEncounterForm(instance=encounter, unit=units)
if not encounter.active:
for field in form:
try:
field.widget.attrs["readonly"] = True
except KeyError:
pass
except AttributeError:
pass
for field in vitals_form:
try:
field.widget.attrs["readonly"] = True
except KeyError:
pass
except AttributeError:
pass
if units == "i":
encounter_update_form_initial_imperial(form, encounter)
form.initial["timestamp"] = encounter.timestamp
encounter_active = encounter.active
suffix = patient.get_suffix_display() if patient.suffix is not None else ""
return render(
request,
"forms/edit_encounter.html",
{
"active": encounter_active,
"aux_form": AuxiliaryPatientEncounterForm(),
"form": form,
"vitals": Vitals.objects.filter(encounter=encounter),
"treatments": Treatment.objects.filter(encounter=encounter),
"vitals_form": vitals_form,
"page_name":
f"Edit Encounter for {patient.first_name} {patient.last_name} {suffix}",
"encounter": encounter,
"birth_sex": patient.sex_assigned_at_birth,
"encounter_id": encounter_id,
"patient_name":
f"{patient.first_name} {patient.last_name} {suffix}",
"units": units,
"patient": patient,
},
)
def patient_delete_view(request, patient_id=None):
"""
Delete function.
:param request: Django Request object.
:param id: The ID of the patient to delete.
:return: HTTPResponse.
"""
if request.method == "POST":
try:
target_object = get_object_or_404(Patient, pk=patient_id)
this_campaign = Campaign.objects.get(
name=request.user.current_campaign)
contact = this_campaign.instance.main_contact
DatabaseChangeLog.objects.create(
action="Delete",
model="Patient",
instance=str(target_object),
ip=get_client_ip(request),
username=request.user.username,
campaign=this_campaign,
)
message_content = (
f"{request.user} has deleted a patient record for the fEMR On-Chain "
f"deployment to {this_campaign} from fEMR On-Chain on {timezone.now()}. "
"To view audit logs, visit the Admin tab in fEMR On-Chain.")
Message.objects.create(
sender=request.user,
recipient=contact,
subject="WARNING! PATIENT DELETED",
content=message_content,
)
send_mail(
"WARNING! PATIENT DELETED",
f"{message_content}\n\n\nTHIS IS AN AUTOMATED MESSAGE FROM fEMR ON-CHAIN. "
"PLEASE DO NOT REPLY TO THIS EMAIL. "
"PLEASE LOG IN TO fEMR ON-CHAIN TO REPLY.",
os.environ.get("DEFAULT_FROM_EMAIL"),
[contact.email],
)
target_object.delete()
except ObjectDoesNotExist:
pass
return_response = render(request, "data/patient_deleted_success.html")
else:
target_object = get_object_or_404(Patient, pk=patient_id)
return_response = render(request, "data/delete.html",
{"patient": target_object})
return return_response
def user_logged_in_callback(sender, request, user, **kwargs):
campaign_list = request.user.campaigns.filter(active=True)
if len(campaign_list) != 0:
name = campaign_list[0].name
campaign = Campaign.objects.get(name=name)
else:
campaign = None
AuditEntry.objects.create(
action="user_logged_in",
ip=get_client_ip(request),
username=user.username,
campaign=campaign,
browser_user_agent=request.user_agent.browser.family,
system_user_agent=request.user_agent.os.family,
)
def update_user_view(request, user_id=None):
error = ""
user = get_object_or_404(fEMRUser, pk=user_id)
if request.method == "POST":
form = (fEMRAdminUserUpdateForm(request.POST or None, instance=user)
if request.user.groups.filter(
name="fEMR Admin").exists() else UserUpdateForm(
request.user, request.POST or None, instance=user))
if form.is_valid():
item = form.save()
item.save()
DatabaseChangeLog.objects.create(
action="Edit",
model="User",
instance=str(item),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(
name=request.user.current_campaign),
)
return_response = render(request, "admin/user_edit_confirmed.html")
else:
return_response = render(
request,
"admin/user_edit_form.html",
{
"error": "Form is invalid.",
"form": form,
"user_id": user_id,
"page_name": "Editing User",
},
)
else:
form = (fEMRAdminUserUpdateForm(instance=user)
if request.user.groups.filter(name="fEMR Admin").exists() else
UserUpdateForm(request.user, instance=user))
return_response = render(
request,
"admin/user_edit_form.html",
{
"error": error,
"form": form,
"user_id": user_id,
"page_name": "Editing User",
},
)
return return_response
def new_vitals_view_post(request, units, encounter):
vitals_form = VitalsForm(request.POST, unit=units)
if vitals_form.is_valid():
vitals = vitals_form.save(commit=False)
vitals.encounter = encounter
vitals.save()
DatabaseChangeLog.objects.create(
action="New",
model="Vitals",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
def __edit_photo_view_post(request, patient_id, encounter_id, photo_id):
units = Campaign.objects.get(name=request.user.current_campaign).units
encounter = get_object_or_404(PatientEncounter, pk=encounter_id)
patient = get_object_or_404(Patient, pk=patient_id)
photo = Photo.objects.get(pk=photo_id)
aux_form = PhotoForm(request.POST, request.FILES, instance=photo)
if aux_form.is_valid():
photo = aux_form.save()
try:
photo.save()
except ValueError:
photo.delete()
DatabaseChangeLog.objects.create(
action="Edit",
model="Photo",
instance=str(photo),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
vitals_form = VitalsForm(unit=units)
suffix = patient.get_suffix_display(
) if patient.suffix is not None else ""
return render(
request,
"forms/photos_tab.html",
{
"aux_form": aux_form,
"vitals": Vitals.objects.filter(encounter=encounter),
"treatments": Treatment.objects.filter(encounter=encounter),
"vitals_form": vitals_form,
"page_name":
f"Edit Encounter for {patient.first_name} {patient.last_name} {suffix}",
"encounter": encounter,
"birth_sex": patient.sex_assigned_at_birth,
"encounter_id": encounter_id,
"patient_name":
f"{patient.first_name} {patient.last_name} {suffix}",
"units": units,
"patient": patient,
},
)
def __create_user_view_post(request):
form = (fEMRAdminUserForm(request.POST) if request.user.groups.filter(
name="fEMR Admin").exists() else UserForm(request.POST))
if form.is_valid():
item = form.save()
form.save_m2m()
item.created_by = request.user
item.user_permissions.add(Permission.objects.get(name="Can add state"))
item.user_permissions.add(
Permission.objects.get(name="Can add diagnosis"))
item.user_permissions.add(
Permission.objects.get(name="Can add chief complaint"))
item.user_permissions.add(
Permission.objects.get(name="Can add medication"))
item.user_permissions.add(
Permission.objects.get(name="Can add administration schedule"))
item.user_permissions.add(
Permission.objects.get(name="Can add inventory category"))
item.user_permissions.add(
Permission.objects.get(name="Can add inventory form"))
item.user_permissions.add(
Permission.objects.get(name="Can add manufacturer"))
item.save()
DatabaseChangeLog.objects.create(
action="Create",
model="User",
instance=str(item),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
return_response = render(request, "admin/user_edit_confirmed.html")
else:
return_response = render(
request,
"admin/user_create_form.html",
{
"error": "Form is invalid.",
"form": form
},
)
return return_response
def __upload_photo_view_post(request, encounter):
aux_form = PhotoForm(request.POST, request.FILES)
if aux_form.is_valid():
photo = aux_form.save()
photo.save()
encounter.photos.add(photo)
encounter.save()
aux_form = PhotoForm()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
return aux_form
def __patient_edit_form_get(request, patient_id, patient, encounters):
DatabaseChangeLog.objects.create(
action="View",
model="Patient",
instance=str(patient),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
form = PatientForm(instance=patient)
return render(
request,
"forms/patient.html",
{
"error": "",
"patient_id": patient_id,
"encounters": encounters,
"form": form,
"page_name": "Returning Patient",
},
)
def __patient_edit_form_post(request, patient_id, patient, encounters):
form = PatientForm(request.POST or None, instance=patient)
campaign_key = patient.campaign_key
if form.is_valid():
patient = form.save()
patient.campaign_key = campaign_key
patient.campaign.add(
Campaign.objects.get(name=request.user.current_campaign))
patient.save()
DatabaseChangeLog.objects.create(
action="Edit",
model="Patient",
instance=str(patient),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
update_patient(form.cleaned_data)
return_response = render(
request,
"data/patient_submitted.html",
{
"patient": patient,
"encounters": encounters
},
)
else:
return_response = render(
request,
"forms/patient.html",
{
"error": "Form is invalid.",
"patient_id": patient_id,
"encounters": encounters,
"form": form,
"page_name": "Returning Patient",
},
)
return return_response
def __patient_encounter_form_post(request, patient):
telehealth = Campaign.objects.get(name=request.user.current_campaign).telehealth
units = Campaign.objects.get(name=request.user.current_campaign).units
encounter_open = (
len(PatientEncounter.objects.filter(patient=patient).filter(active=True)) > 0
)
form = PatientEncounterForm(request.POST, unit=units, prefix="form")
vitals_form = VitalsForm(request.POST, unit=units, prefix="vitals_form")
treatment_form = TreatmentForm()
diagnosis_form = DiagnosisForm()
if form.is_valid() and vitals_form.is_valid():
encounter = form.save(commit=False)
vitals = vitals_form.save(commit=False)
encounter.patient = patient
encounter.active = True
encounter.campaign = Campaign.objects.get(name=request.user.current_campaign)
encounter.save()
vitals.encounter = encounter
vitals.save()
form.save_m2m()
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
create_new_patient_encounter(encounter_data)
DatabaseChangeLog.objects.create(
action="Create",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
DatabaseChangeLog.objects.create(
action="Create",
model="Vitals",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if "submit_encounter" in request.POST:
return_response = render(
request,
"data/encounter_submitted.html",
{"patient_id": patient.id, "encounter_id": encounter.id},
)
elif "submit_refer" in request.POST:
kwargs = {"patient_id": patient.id}
return_response = redirect("main:referral_form_view", **kwargs)
else:
return_response = render(
request,
"data/encounter_submitted.html",
{"patient_id": patient.id, "encounter_id": encounter.id},
)
else:
suffix = patient.get_suffix_display() if patient.suffix is not None else ""
return_response = render(
request,
"forms/encounter.html",
{
"form": form,
"vitals_form": vitals_form,
"diagnosis_form": diagnosis_form,
"treatment_form": treatment_form,
"page_name": f"New Encounter for {patient.first_name} {patient.last_name} {suffix}",
"birth_sex": patient.sex_assigned_at_birth,
"patient_id": patient.id,
"units": units,
"telehealth": telehealth,
"encounter_open": encounter_open,
"page_tip": "Complete form with patient vitals as instructed. "
"Any box with an asterisk (*) is required. "
"For max efficiency, use 'tab' to navigate through this page.",
},
)
return return_response
def __patient_form_view_post(request, campaign):
form = PatientForm(request.POST)
ssn_error = False
phone_error = False
email_error = False
shared_phone_error = False
shared_email_error = False
match = None
if form.is_valid():
item = form.save()
item.campaign.add(campaign)
key = None
while key is None:
key = cal_key(campaign)
item.campaign_key = key
item.save()
if os.environ.get("QLDB_ENABLED") == "TRUE":
create_new_patient(form.cleaned_data)
DatabaseChangeLog.objects.create(
action="Create",
model="Patient",
instance=str(item),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if item.id != "" and item.id is not None:
return_response = render(
request,
"data/patient_submitted.html",
{"patient": item, "encounters": []},
)
else:
return_response = render(request, "data/patient_not_submitted.html")
else:
if (
"social_security_number" in form.errors
and "Must be 4 or 9 digits" not in form.errors["social_security_number"][0]
):
ssn_error = True
match = Patient.objects.get(
social_security_number=form.data["social_security_number"]
)
if "phone_number" in form.errors:
phone_error = True
match = Patient.objects.filter(phone_number=form.data["phone_number"])
if "email_address" in form.errors:
email_error = True
match = Patient.objects.filter(email_address=form.data["email_address"])
form.fields["race"].queryset = campaign.race_options
form.fields["ethnicity"].queryset = campaign.ethnicity_options
return_response = render(
request,
"forms/new_patient.html",
{
"ssn_error": ssn_error,
"phone_error": phone_error,
"email_error": email_error,
"shared_phone_error": shared_phone_error,
"shared_email_error": shared_email_error,
"match_list": match,
"form": form,
"page_name": "New Patient",
"page_tip": "Complete form with patient demographics as instructed. "
"Any box with an asterisk (*) is required. "
"Shared contact information would be if two patients have a "
"household phone or email that they share, for example.",
},
)
return return_response
def __encounter_edit_form_post(request, patient_id, encounter_id):
encounter = get_object_or_404(PatientEncounter, pk=encounter_id)
patient = get_object_or_404(Patient, pk=patient_id)
units = Campaign.objects.get(name=request.user.current_campaign).units
photos = encounter.photos.all().iterator()
treatments = Treatment.objects.filter(encounter=encounter)
form = PatientEncounterForm(request.POST or None,
instance=encounter,
unit=units)
if form.is_valid():
encounter = form.save(commit=False)
form.save_m2m()
encounter.patient = patient
encounter.active = True
encounter.photos.set(photos)
encounter.save()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(encounter).data
update_patient_encounter(encounter_data)
if "submit_encounter" in request.POST:
return_response = render(
request,
"data/encounter_submitted.html",
{
"patient_id": patient_id,
"encounter_id": encounter_id
},
)
elif "submit_refer" in request.POST:
kwargs = {"patient_id": patient_id}
return_response = redirect("main:referral_form_view", **kwargs)
else:
return_response = render(
request,
"data/encounter_submitted.html",
{
"patient_id": patient_id,
"encounter_id": encounter_id
},
)
else:
form.initial["timestamp"] = encounter.timestamp
encounter_active = encounter.active
suffix = patient.get_suffix_display(
) if patient.suffix is not None else ""
return_response = render(
request,
"forms/edit_encounter.html",
{
"active": encounter_active,
"aux_form": AuxiliaryPatientEncounterForm(),
"form": form,
"vitals": Vitals.objects.filter(encounter=encounter),
"treatments": treatments,
"vitals_form": VitalsForm(unit=units),
"page_name":
f"Edit Encounter for {patient.first_name} {patient.last_name} {suffix}",
"encounter": encounter,
"birth_sex": patient.sex_assigned_at_birth,
"encounter_id": encounter_id,
"patient_name":
f"{patient.first_name} {patient.last_name} {suffix}",
"units": units,
"patient": patient,
},
)
return return_response
def history_view(request, patient_id=None, encounter_id=None):
if request.user.is_authenticated:
if request.user.current_campaign == "RECOVERY MODE":
return_response = redirect("main:home")
else:
units = Campaign.objects.get(
name=request.user.current_campaign).units
encounter = get_object_or_404(PatientEncounter, pk=encounter_id)
patient = get_object_or_404(Patient, pk=patient_id)
aux_form = HistoryPatientEncounterForm(instance=encounter)
if request.method == "POST":
aux_form = HistoryPatientEncounterForm(request.POST)
if aux_form.is_valid():
encounter.medical_history = request.POST["medical_history"]
encounter.social_history = request.POST["social_history"]
encounter.current_medications = request.POST[
"current_medications"]
encounter.family_history = request.POST["family_history"]
encounter.save()
DatabaseChangeLog.objects.create(
action="Edit",
model="PatientEncounter",
instance=str(encounter),
ip=get_client_ip(request),
username=request.user.username,
campaign=Campaign.objects.get(
name=request.user.current_campaign),
)
if os.environ.get("QLDB_ENABLED") == "TRUE":
encounter_data = PatientEncounterSerializer(
encounter).data
update_patient_encounter(encounter_data)
return_response = render(
request,
"data/encounter_submitted.html",
{
"patient_id": patient_id,
"encounter_id": encounter_id
},
)
else:
form = PatientEncounterForm(instance=encounter, unit=units)
vitals_form = VitalsForm(unit=units)
if units == "i":
history_view_imperial(form, encounter)
suffix = (patient.get_suffix_display()
if patient.suffix is not None else "")
return_response = render(
request,
"forms/history_tab.html",
{
"form":
form,
"aux_form":
aux_form,
"vitals":
Vitals.objects.filter(encounter=encounter),
"treatments":
Treatment.objects.filter(encounter=encounter),
"vitals_form":
vitals_form,
"page_name":
f"Edit Encounter for {patient.first_name} {patient.last_name} {suffix}",
"encounter":
encounter,
"birth_sex":
patient.sex_assigned_at_birth,
"patient_id":
patient_id,
"encounter_id":
encounter_id,
"patient_name":
f"{patient.first_name} {patient.last_name} {suffix}",
"units":
units,
"patient":
patient,
},
)
else:
return_response = __history_view_get(request, encounter_id,
units, patient, aux_form)
else:
return_response = redirect("/not_logged_in")
return return_response