def exams(request):
data_client = DataClient()
completed = get_sidebar_completed()
if request.method == 'POST':
exams_form = ExamsForm(request.POST)
if exams_form.is_valid():
chosen_list = []
for field in exams_form.fields:
if (exams_form.cleaned_data[field]):
chosen_list.append(field)
if not chosen_list:
return HttpResponseRedirect('/app/exams/')
else:
data_client.exams_chosen = chosen_list
return HttpResponseRedirect('/app/exams/details')
else:
exams_form = ExamsForm()
completed = get_sidebar_completed()
exams_completed = get_exams_completed()
# Delete this out later, just want to see that it works
print(exams_completed)
return render(
request, 'app/exams.html', {
'exams_form': exams_form,
'patient': data_client.patient,
'completed': completed,
'exams_completed': exams_completed
})
def assessments(request):
data_client = DataClient()
completed = get_sidebar_completed()
tests_completed = get_tests_completed()
if request.method == 'POST':
assessments_form = AssessmentForm(request.POST)
if assessments_form.is_valid():
chosen_list = []
for field in assessments_form.fields:
if (assessments_form.cleaned_data[field]):
chosen_list.append(field)
if not chosen_list:
return HttpResponseRedirect('/app/assessments/')
else:
data_client.assessments_chosen = chosen_list
return HttpResponseRedirect('/app/assessments/details')
else:
assessments_form = AssessmentForm()
# Comment this out later, just want to see it works
# print(tests_completed)
return render(
request, 'app/assessments.html', {
'assessments_form': assessments_form,
'patient': data_client.patient,
'completed': completed,
'tests_completed': tests_completed
})
def history(request):
data_client = DataClient()
encounter_list = []
if (request.GET.get('patient') != None):
data_client.patient = literal_eval(request.GET.get('patient'))
data_client.fhir_client.select_patient(
data_client.patient['resource']['id'])
encounter_list = sorted(data_client.fhir_client.search_encounter_all(),
key=cmp_to_key(mycmp))
# encounter_order = ['in-progress', 'arrived', 'finished']
for encounter in encounter_list:
# patient_id_list = encounter['resource']['patient']['reference'].split('/')
# patient_id = ""
# if len(patient_id_list) > 1:
# patient_id = patient_id_list[1]
observations = data_client.fhir_client.search_observations(
enc=encounter['resource']['id'])
if data_client.risk_list['code'] in observations.keys():
encounter['risk_level'] = observations[
data_client.risk_list['code']]
return render(request, 'app/history.html', {
'encounters': encounter_list,
'patient': data_client.patient
})
def risks(request):
data_client = DataClient()
completed = get_sidebar_completed()
incomplete_list = calculate_risk()
if request.method == "POST":
risk_level = data_client.risk_level
risks_form = RisksForm(request.POST, risk_level=risk_level)
if risks_form.is_valid():
for key, intervention in data_client.intervention_list.items():
for i, form in enumerate(intervention['forms']):
code = intervention['forms'][i]['code']
print(risks_form.cleaned_data)
if code in risks_form.cleaned_data:
answer = risks_form.cleaned_data[code]
data_client.observations[code] = answer
#save observations to FHIR server
data_client.fhir_client.write_list_of_observations_to_fhir(
data=data_client.observations)
return HttpResponseRedirect('/app/risks')
else:
intervention_answers = {}
for key, intervention in data_client.intervention_list.items():
for i, form in enumerate(intervention['forms']):
code = intervention['forms'][i]['code']
if code in data_client.observations:
field_name = code
intervention_answers[
field_name] = data_client.observations[code]
if isinstance(intervention_answers[field_name], str):
if intervention_answers[field_name] == "True":
intervention_answers[field_name] = True
elif intervention_answers[field_name] == "False":
intervention_answers[field_name] = False
risk_level = data_client.risk_level
if data_client.risk_level == "low":
risks_form = RisksForm(initial=intervention_answers,
risk_level="low")
elif data_client.risk_level == "moderate":
risks_form = RisksForm(initial=intervention_answers,
risk_level="moderate")
elif data_client.risk_level == "high":
risks_form = RisksForm(initial=intervention_answers,
risk_level="high")
else:
risks_form = RisksForm(initial=intervention_answers,
risk_level="incomplete",
incomplete_list=incomplete_list)
return render(
request, 'app/risks.html', {
'risks_form': risks_form,
'risk_level': risk_level,
'incomplete_list': incomplete_list,
'completed': completed,
'patient': data_client.patient
})
def get_sidebar_completed():
"""
Returns a list of completed sidebar tasks
"""
completed = {}
data_client = DataClient()
obs = data_client.observations
question_code = data_client.questions['code']
test_codes = []
tests = data_client.func_test
for test in tests:
test_codes.append(test['code'])
if question_code in obs:
completed["screening"] = True
for test_code in test_codes:
if test_code in obs:
completed["assessments"] = True
break
for exam in data_client.physical_exam:
for form in exam['forms']:
if form['code'] in obs:
completed["exams"] = True
break
if data_client.medication_complete:
completed["medication"] = True
if data_client.risks_complete:
completed["risks"] = True
return completed
def __init__(self, *args, **kwargs):
super(AssessmentForm, self).__init__(*args, **kwargs)
data_client = DataClient()
# assessments_chosen = data_client.assessments_chosen
self.helper = FormHelper()
self.helper.layout = Layout()
field_set = Fieldset("Please select assessment(s) to complete")
for test in data_client.func_test:
if test['code'] in data_client.observations:
self.fields[test['code']] = forms.BooleanField(
label=test['name'] + " (Completed)",
required=False,
)
elif test['is_recommended']:
self.fields[test['code']] = forms.BooleanField(
label=test['name'] + " (Recommended)",
required=False,
)
else:
self.fields[test['code']] = forms.BooleanField(
label=test['name'],
required=False,
)
field_set.append(Field(test['code']))
self.helper.layout.append(field_set)
self.helper.add_input(Submit('submit', 'Next'))
self.helper.form_id = 'id-assessmentForm'
self.helper.form_method = 'post'
def __init__(self, *args, **kwargs):
assessments_chosen = kwargs.pop("assessments_chosen", None)
super(AssessmentDetailsForm, self).__init__(*args, **kwargs)
data_client = DataClient()
# assessments_chosen = data_client.assessments_chosen
self.helper = FormHelper()
self.helper.layout = Layout()
i = 0
if assessments_chosen:
# self.helper.layout.append(HTML (
# <span id="hiddenTag" style="display: none">{{ i }}</span>
# ))
# self.helper.layout.append(Button (
# ))
for test in data_client.func_test:
if test['code'] in assessments_chosen:
code = test['code']
test_fieldset = Fieldset(test['name'],
css_class=test['name'])
# self.helper.layout.append(Button(test['code'], test['code']))
for i, form in enumerate(test['forms']):
code = test['forms'][i]['code']
field_name = code
self.fields[field_name] = generate_form(
form, None, None)
test_fieldset.append(Field(field_name))
# self.fields[field_name].widget = forms.HiddenInput()
self.helper.layout.append(test_fieldset)
self.helper.add_input(Submit('submit', 'Submit'))
self.helper.form_id = 'id-assessmentForm'
self.helper.form_method = 'post'
def __init__(self, *args, **kwargs):
super(ExamsForm, self).__init__(*args, **kwargs)
data_client = DataClient()
completed = []
obs = data_client.observations
for exam in data_client.physical_exam:
for form in exam['forms']:
if form['code'] in obs:
completed.append(exam['code'])
break
self.helper = FormHelper()
self.helper.layout = Layout()
field_set = Fieldset("Please select exam(s) to complete")
for exam in data_client.physical_exam:
if exam['code'] in completed:
self.fields[exam['code']] = forms.BooleanField(
label=exam['name'] + " (Completed)",
required=False,
)
else:
self.fields[exam['code']] = forms.BooleanField(
label=exam['name'],
required=False,
)
field_set.append(Field(exam['code']))
self.helper.layout.append(field_set)
self.helper.add_input(Submit('submit', 'Next'))
self.helper.form_id = 'id-examsForm'
self.helper.form_method = 'post'
def exams_details(request):
data_client = DataClient()
exams_chosen = data_client.exams_chosen
completed = get_sidebar_completed()
if request.method == 'POST':
exams_form = ExamsDetailsForm(request.POST, exams_chosen=exams_chosen)
if exams_form.is_valid():
# Local obs just in case
observations = {}
for exam in data_client.physical_exam:
if exam['code'] in exams_chosen:
for i, form in enumerate(exam['forms']):
code = exam['forms'][i]['code']
field_name = code
answer = exams_form.cleaned_data[field_name]
data_client.observations[code] = answer
observations[code] = answer
# Clear this for the next iteration...
data_client.exams_chosen = []
# Exams is last stop before risks, all levels go to risks including incomplete
#save observations to FHIR server
data_client.fhir_client.write_list_of_observations_to_fhir(
data=data_client.observations)
return HttpResponseRedirect('/app/risks/')
else:
exam_answers = {}
for exam in data_client.physical_exam:
if exam['code'] in exams_chosen:
for i, form in enumerate(exam['forms']):
code = exam['forms'][i]['code']
if code in data_client.observations:
field_name = code
exam_answers[field_name] = data_client.observations[
code]
if isinstance(exam_answers[field_name], str):
if exam_answers[field_name] == "True":
exam_answers[field_name] = True
elif exam_answers[field_name] == "False":
exam_answers[field_name] = False
exams_form = ExamsDetailsForm(initial=exam_answers,
exams_chosen=exams_chosen)
return render(
request, 'app/exams.html', {
'exams_form': exams_form,
'patient': data_client.patient,
'completed': completed
})
def login_patient(request):
data_client = DataClient()
if request.method == 'POST':
login_cp_form = LoginCPForm(request.POST)
if login_cp_form.is_valid():
url = '/app/questions/'
return HttpResponseRedirect(url)
else:
login_cp_form = LoginCPForm()
return render(request, 'app/login_cp.html',
{'login_cp_form': login_cp_form})
def __init__(self, *args, **kwargs):
super(MedicationsForm, self).__init__(*args, **kwargs)
data_client = DataClient()
self.helper = FormHelper()
self.helper.form_id = 'id-problemsForms'
self.helper.form_method = 'post'
# self.helper.layout = Layout()
for i, form in enumerate(data_client.med_form['forms']):
code = data_client.med_form['forms'][i]['code']
field_name = code
self.fields[field_name] = generate_form(form)
# self.helper.layout.append(checked_medications)
self.helper.add_input(Submit('submit', 'Submit'))
def clean(self):
"""
This is a custom override
"""
data_client = DataClient()
cleaned_data = super(ExamsForm, self).clean()
selected_exams = False
for exam, value in cleaned_data.items():
if value:
selected_exams = True
break
if not selected_exams:
raise forms.ValidationError("Please select at least one exam")
return cleaned_data
def get_exams_completed():
"""
Returns a list of completed exams
"""
completed = []
data_client = DataClient()
obs = data_client.observations
for exam in data_client.physical_exam:
for form in exam['forms']:
if form['code'] in obs:
completed.append(exam['code'])
break
return completed
def clean(self):
"""
This is a custom override
"""
data_client = DataClient()
cleaned_data = super(AssessmentForm, self).clean()
selected_tests = False
for exam, value in cleaned_data.items():
if value:
selected_tests = True
break
if not selected_tests:
raise forms.ValidationError("Please select at least one exam")
return cleaned_data
# Could set obs. here to have in record despite incomplete?
return cleaned_data
def clean(self):
"""
This is a custom override
"""
data_client = DataClient()
cleaned_data = super(QuestionForm, self).clean()
num_falls = cleaned_data.get("q001")
injury = cleaned_data.get("q003")
if injury and num_falls == 0:
msg = "It is not possible to have been injured without having a fall"
self.add_error('q001', msg)
self.add_error('q003', msg)
raise forms.ValidationError("Please fix the fields")
# Could set obs. here to have in record despite incomplete?
return cleaned_data
def get_tests_completed():
"""
Returns a list of completed tests
"""
completed = []
data_client = DataClient()
obs = data_client.observations
test_codes = []
tests = data_client.func_test
for test in tests:
test_codes.append(test['code'])
for code in test_codes:
if code in obs:
completed.append(code)
return completed
def __init__(self, *args, **kwargs):
exams_chosen = kwargs.pop("exams_chosen", None)
super(ExamsDetailsForm, self).__init__(*args, **kwargs)
data_client = DataClient()
self.helper = FormHelper()
self.helper.layout = Layout()
if exams_chosen:
for exam in data_client.physical_exam:
if exam['code'] in exams_chosen:
exam_fieldset = Fieldset(exam['name'],
css_class=exam['name'])
for i, form in enumerate(exam['forms']):
code = exam['forms'][i]['code']
field_name = code
self.fields[field_name] = generate_form(form)
exam_fieldset.append(Field(field_name))
self.helper.layout.append(exam_fieldset)
self.helper.add_input(Submit('submit', 'Submit'))
self.helper.form_id = 'id-examsForm'
self.helper.form_method = 'post'
def __init__(self, *args, **kwargs):
super(QuestionForm, self).__init__(*args, **kwargs)
data_client = DataClient()
for i, question in enumerate(data_client.questions['questions']):
code = data_client.questions['questions'][i]['code']
field_name = code
choice_list = []
for choice_pair in question['choices']:
pair_array = []
pair_array.append(choice_pair["value"])
pair_array.append(choice_pair["text"])
choice_list.append(pair_array)
choice_tuple = tuple(tuple(x) for x in choice_list)
self.fields[field_name] = generate_form(question,
forms.RadioSelect,
field_choices=choice_tuple)
# Could expand on standards doc by requiring things to be filled in dynamically
self.fields[field_name].required = True
self.helper = FormHelper()
self.helper.form_id = 'id-questionsForm'
self.helper.form_method = 'post'
self.helper.add_input(Submit('submit', 'Next'))
def __init__(self, *args, **kwargs):
risk_level = kwargs.pop("risk_level", None)
incomplete = kwargs.pop("incomplete_list", None)
super(RisksForm, self).__init__(*args, **kwargs)
data_client = DataClient()
self.helper = FormHelper()
self.helper.layout = Layout()
intervention_list = []
print(risk_level)
if risk_level == "low" or risk_level == "incomplete":
for intervention in data_client.risk_list["risks"]["low_risk"]:
intervention_list.append(intervention)
elif risk_level == "moderate":
for intervention in data_client.risk_list["risks"][
"moderate_risk"]:
intervention_list.append(intervention)
elif risk_level == "high":
for intervention in data_client.risk_list["risks"]["high_risk"]:
intervention_list.append(intervention)
print(intervention_list)
# Pythonic way to check if list isn't empty
if intervention_list:
for intervention in intervention_list:
current_intervention = data_client.intervention_list[
intervention]
intervention_fieldset = Fieldset(current_intervention['name'],
css_class='field_set_results')
for i, form in enumerate(current_intervention['forms']):
code = current_intervention['forms'][i]['code']
field_name = code
self.fields[field_name] = generate_form(form)
intervention_fieldset.append(Field(field_name))
self.helper.layout.append(intervention_fieldset)
print("here")
self.helper.form_id = 'id-risksForm'
self.helper.form_method = 'post'
self.helper.add_input(Submit('submit', 'Complete'))
def clean(self):
"""
This is a custom override
"""
data_client = DataClient()
problem_list = []
cleaned_data = super(AssessmentDetailsForm, self).clean()
cant_tug = cleaned_data.get("tug001")
tug_time = cleaned_data.get("tug002")
no_problems = cleaned_data.get("tug003")
error = False
for test in data_client.func_test:
if test['code'] == "tug000":
for field in test['forms']:
if field['is_problem']:
problem_list.append(field['code'])
if cant_tug is not None and cant_tug:
if tug_time is not None:
time_msg = "Either uncheck the box above or please leave this blank"
self.add_error('tug002', time_msg)
error = True
if no_problems is not None and no_problems:
prob_msg = "It is not possible to unable to do the TUG while having timed score or no problems"
self.add_error('tug001', prob_msg)
error = True
if no_problems is not None and no_problems:
msg = "It is not possible to have no problems checked off with other problems"
for code in problem_list:
if code in cleaned_data and cleaned_data[code]:
self.add_error(code, msg)
error = True
if error:
raise forms.ValidationError("Please fix the fields")
# Could set obs. here to have in record despite incomplete?
return cleaned_data
def search_patient(request):
data_client = DataClient()
# patient_list = []
data_client.reload_data()
if request.method == 'POST':
search_patient_form = SearchPatientForm(request.POST)
if search_patient_form.is_valid():
data_client = DataClient()
patient_name = search_patient_form.cleaned_data[
'patient_name'].split()
# Search for a patient by first and last name
data_client.patient_list = data_client.fhir_client.search_patient(
patient_name[0], patient_name[1])
# if patient_list:
# data_client.patient = patient_list[0]
# data_client.fhir_client.select_patient(data_client.patient['resource']['id'])
# url = '/app/questions/'
# return HttpResponseRedirect(url)
else:
search_patient_form = SearchPatientForm()
if data_client.identity != "care_provider":
return HttpResponseRedirect('/app/login/')
patient_paginator = Paginator(data_client.patient_list, 3)
try:
page = int(request.GET.get('page', '1'))
patients = patient_paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
patients = patient_paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
patients = patient_paginator.page(patient_paginator.num_pages)
return render(request, 'app/search_patient.html', {
'search_patient_form': search_patient_form,
'patients': patients
})
def login(request):
data_client = DataClient()
data_client.reload_data()
# Wipe whatever is in memory...?
# data_client = DataClient().clean()
if request.method == 'POST':
login_form = LoginForm(request.POST)
if login_form.is_valid():
identity = login_form.cleaned_data['identity']
if identity == 'patient':
url = '/app/login/patient/'
data_client.identity = 'patient'
elif identity == "care_provider":
url = '/app/login/care_provider/'
data_client.identity = 'care_provider'
return HttpResponseRedirect(url)
else:
login_form = LoginForm()
return render(request, 'app/login.html', {'login_form': login_form})
def assessments_details(request):
"""
If there's anything in this project that needs refactoring, this is it.
"""
data_client = DataClient()
assessments_chosen = data_client.assessments_chosen
completed = get_sidebar_completed()
more_info = {}
for assessment in assessments_chosen:
for test in data_client.func_test:
if (test['code'] == assessment):
more_info[assessment] = test['more_info']
for key, value in more_info.items():
for test in data_client.func_test:
if test["code"] == key:
more_info[key]["name"] = test["name"]
if request.method == 'POST':
assessments_form = AssessmentDetailsForm(
request.POST, assessments_chosen=assessments_chosen)
if assessments_form.is_valid():
# Local obs just in case
observations = {}
# Boolean to ultimately determine if patient fails GSB
has_problem = False
# Score of how many key questions have been answered 'yes' (use 0 because adds 1 each iteration)
tug_key = 0
# Minimum amount of key questions needed to be answered 'yes' to fail (use -1 as a check if test conducted)
tug_min_key = -1
# Score of how many evaluations have exceeded their respective min time (use 0 because adds 1 each iteration)
bal_failure = 0
# Minimum amount of failures for evaluations to fail the test overall (use -1 as a check if test conducted)
bal_min_failure = -1
# Minimum amount of time needed for patient to stand in chair (use -1 as a check if test conducted)
chair_min_failure = -1
bal_score = 0
tug_conducted = False
bal_conducted = False
chair_conducted = False
for test in data_client.func_test:
if test['code'] in data_client.assessments_chosen:
# Pulls required fields to evaluate logic
if test['code'] == "tug000":
tug_min_key = test['min_logic']['min_key']
tug_conducted = True
elif test['code'] == "bal000":
bal_min_failure = test['min_logic']['min_failure']
bal_conducted = True
elif test['code'] == "chair000":
chair_conducted = True
for i, form in enumerate(test['forms']):
code = test['forms'][i]['code']
field_name = code
answer = assessments_form.cleaned_data[field_name]
data_client.observations[code] = answer
observations[code] = answer
# Check logic for TUG
if test['code'] == "tug000":
# Check for key questions
if test['forms'][i]['type'] == 'boolean':
if test['forms'][i]['is_key'] and answer:
tug_key = tug_key + 1
if test['forms'][i][
'code'] == 'tug001' and answer:
has_problem = True
data_client.observations["tug000"] = "Fail"
observations["tug000"] = "Fail"
# Check for timing scores
if test['forms'][i]['type'] == 'integer':
# Check to make sure it isnt NoneType
if answer is not None:
form_logic = test['forms'][i]['logic']
if form_logic in test['min_logic']:
if answer < test['min_logic'][
form_logic]:
has_problem = True
data_client.observations[
"tug000"] = "Fail"
observations["tug000"] = "Fail"
# Check logic for 30 Chair
if test['code'] == 'chair000':
if test['forms'][i]['type'] == 'integer':
form_logic = test['forms'][i]['logic']
if form_logic in test['min_logic']:
patient_gender = data_client.patient[
'resource']['gender']
date_string = data_client.patient[
'resource']['birthDate']
patient_age = calculate_age(date_string)
age_index = test['min_logic'][form_logic][
'ages']
male_score = test['min_logic'][form_logic][
'male']
female_score = test['min_logic'][
form_logic]['female']
if patient_age < age_index[0]:
print(
"Age is less than minimum age for test, will pass since score irrelevant"
)
if patient_age > age_index[-1]:
print(
"Age is greater than maximum age for test, will fail since score irrelevant"
)
else:
print(age_index)
for i, age in enumerate(age_index):
if patient_age >= age:
continue
else:
index = i - 1
break
if patient_gender == 'male':
chair_min_failure = male_score[index]
elif patient_gender == 'female':
chair_min_failure = female_score[index]
if answer is not None and chair_min_failure >= 0:
if answer < chair_min_failure:
has_problem = True
data_client.observations[
"chair000"] = "Fail"
observations["chair000"] = "Fail"
# Check logic for Balance Test
if test['code'] == 'bal000':
if test['forms'][i]['type'] == 'integer':
# Bug here: what if logic doesn't exist?
form_logic = test['forms'][i]['logic']
if form_logic in test['min_logic']:
# However, still force them to enter 0 so that the field is acknowledged
if answer is None:
bal_score = bal_score + 1
if answer is not None and answer < test[
'min_logic'][form_logic]:
bal_score = bal_score + 1
# Final logic checks for tests
if tug_min_key >= 0 and tug_key > tug_min_key:
# print ("has problem from key tugs")
has_problem = True
data_client.observations["tug000"] = "Fail"
observations["tug000"] = "Fail"
if bal_min_failure >= 0 and bal_score > bal_min_failure:
# print ('has problem from key bal')
has_problem = True
data_client.observations["bal000"] = "Fail"
observations["bal000"] = "Fail"
# TODO: If "fail is in before, and someone changes to pass, this wont work."
if tug_conducted:
if "tug000" not in observations:
data_client.observations["tug000"] = "Pass"
if bal_conducted:
if "bal000" not in observations:
data_client.observations["bal000"] = "Pass"
if chair_conducted:
if "chair000" not in observations:
data_client.observations["chair000"] = "Pass"
#save observations to FHIR server
data_client.fhir_client.write_list_of_observations_to_fhir(
data=data_client.observations)
# Wipe clean for next iteration through, if desired to do more assessments
data_client.assessments_chosen = []
# Call calculate_risk at this point...
calculate_risk()
if has_problem:
if data_client.risk_level == "incomplete":
return HttpResponseRedirect('/app/risks/')
else:
return HttpResponseRedirect('/app/medications/')
else:
return HttpResponseRedirect('/app/risks/')
else:
assessments_answers = {}
for test in data_client.func_test:
if test['code'] in data_client.assessments_chosen:
for i, form in enumerate(test['forms']):
code = test['forms'][i]['code']
if code in data_client.observations:
field_name = code
assessments_answers[
field_name] = data_client.observations[code]
if isinstance(assessments_answers[field_name], str):
if assessments_answers[field_name] == "True":
assessments_answers[field_name] = True
elif assessments_answers[field_name] == "False":
assessments_answers[field_name] = False
assessments_form = AssessmentDetailsForm(
initial=assessments_answers, assessments_chosen=assessments_chosen)
return render(
request, 'app/assessments.html', {
'assessments_form': assessments_form,
'patient': data_client.patient,
'completed': completed,
'assessments_chosen': assessments_chosen,
'more_info': more_info
})
def medications(request):
data_client = DataClient()
completed = get_sidebar_completed()
print(completed)
calculate_risk()
med_questions = []
for question in data_client.questions['questions']:
if question['medication_related'] and question[
'code'] in data_client.observations:
if data_client.observations[question['code']]:
med_questions.append(question['content'])
med_names = []
med_codes = []
med_linked_names = []
# Just return something that I can pull name and code from
med = data_client.fhir_client.search_medication()
if med is not None:
for order in med:
code = order['resource']['medicationCodeableConcept']['coding'][0][
'code']
name = order['resource']['medicationCodeableConcept']['coding'][0][
'display']
med_names.append(name)
med_codes.append(code)
med_codes = [int(x) for x in med_codes]
for i, code in enumerate(med_codes):
for med in data_client.medication:
for item in med["rx_codes"]:
if code == item:
med_linked_names.append(med_names[i])
if request.method == 'POST':
medications_form = MedicationsForm(request.POST)
print("Button is triggering")
if medications_form.is_valid():
data_client.medication_complete = True
for i, form in enumerate(data_client.med_form):
code = data_client.med_form['forms'][i]['code']
field_name = code
answer = medications_form.cleaned_data[field_name]
data_client.observations[code] = answer
if data_client.risk_level == "high":
return HttpResponseRedirect('/app/exams/')
else:
return HttpResponseRedirect('/app/risks/')
else:
med_form_answers = {}
for i, form in enumerate(data_client.med_form):
code = data_client.med_form['forms'][i]['code']
if code in data_client.observations:
field_name = code
med_form_answers[field_name] = data_client.observations[code]
if isinstance(med_form_answers[field_name], str):
if med_form_answers[field_name] == "True":
med_form_answers[field_name] = True
elif med_form_answers[field_name] == "False":
med_form_answers[field_name] = False
medications_form = MedicationsForm(initial=med_form_answers)
return render(
request, 'app/medications.html', {
'medications_form': medications_form,
'patient': data_client.patient,
'completed': completed,
'med_questions': med_questions,
'med_names': med_names,
'med_linked_names': med_linked_names
})
def clean(self):
"""
This is a custom override
"""
data_client = DataClient()
problem_list = []
cleaned_data = super(ExamsDetailsForm, self).clean()
left = cleaned_data.get("vis001")
right = cleaned_data.get("vis002")
both = cleaned_data.get("vis003")
eye_list = []
if left != None:
eye_list.append(("vis001", left))
if right != None:
eye_list.append(("vis002", right))
if both != None:
eye_list.append(("vis003", both))
supine = cleaned_data.get("pos001")
standing = cleaned_data.get("pos002")
standing3 = cleaned_data.get("pos003")
pressure_list = []
if supine != None:
pressure_list.append(("pos001", supine))
if standing != None:
pressure_list.append(("pos002", standing))
if standing3 != None:
pressure_list.append(("pos003", standing3))
# This needs to be cleaned up: standards should have fields indicating the type of entry they should have.
# For example, this one would be vision, another could just be "" if you can enter whatever you want
print("Here is the eye list")
print(eye_list)
for s in eye_list:
if s[1] is not None and len(s[1]) > 0 and '/' in s[1]:
print(s)
index = s[1].find('/', 0, len(s[1]))
if index != -1:
first_str = s[1][0:index]
second_str = s[1][index + 1:len(s[1])]
if is_int(first_str) and is_int(second_str):
first_num = int(first_str)
second_num = int(second_str)
if first_num != 20:
self.add_error(
s[0],
"Must be in form \"20/20\": Please ensure the first number is equal to 20"
)
if second_num <= 0:
self.add_error(
s[0],
"Must be in form \"20/20\": Please ensure the second number is positive"
)
else:
self.add_error(
s[0],
"Must be in form \"20/20\": Please ensure numbers are correctly formatted"
)
else:
self.add_error(
s[0],
"Must be in form \"20/20\": Please ensure \"/\" is in entry"
)
else:
self.add_error(s[0], "Must be in form \"20/20\"")
for s in pressure_list:
if s[1] is not None and len(s[1]) > 0 and '/' in s[1]:
print(s)
index = s[1].find('/', 0, len(s[1]))
if index != -1:
first_str = s[1][0:index]
second_str = s[1][index + 1:len(s[1])]
if is_int(first_str) and is_int(second_str):
first_num = int(first_str)
second_num = int(second_str)
if first_num <= 20:
self.add_error(
s[0],
"Must be in form \"120/80\": Please ensure the first number is positive"
)
if second_num <= 0:
self.add_error(
s[0],
"Must be in form \"120/80\": Please ensure the second number is positive"
)
else:
self.add_error(
s[0],
"Must be in form \"120/80\": Please ensure numbers are correctly formatted"
)
else:
self.add_error(
s[0],
"Must be in form \"120/80\": Please ensure \"/\" is in entry"
)
else:
self.add_error(s[0], "Must be in form \"120/80\"")
return cleaned_data
def index(request):
DataClient()
return render(request, 'app/index.html', {'form': MessageForm()})
def calculate_risk():
"""
Function that updates the current status of the risk level based on what's written in the observation list
That is, it can be called at any time to know the status of the risk level
Returns a list of things yet to be completed
"""
data_client = DataClient()
risk_code = data_client.risk_list['code']
obs = data_client.observations
# Set to "Pass" and "Fail"
question_fail = None
assessment_fail = None
num_falls = None
injury = None
incomplete_list = []
question_code = data_client.questions['code']
tests = data_client.func_test
test_codes = []
for test in tests:
test_codes.append(test['code'])
# Check if questions have been completed
if question_code in obs:
question_fail = obs["q000"]
num_falls = obs["q001"]
num_falls = int(num_falls)
injury = obs["q003"]
# Check each test; If one has failed then assesment_fail is fail guaranteed
for code in test_codes:
if code in obs and obs[code] == "Fail":
assessment_fail = "Fail"
break
# If wasn't set to Fail above but one of the tests is in obs, then the patient had no problems, and so they passed
for code in test_codes:
if code in obs:
if assessment_fail == None:
assessment_fail = "Pass"
# Algorithm
if question_fail is None:
data_client.risk_level = "incomplete"
incomplete_list.append("Fall Screening")
if assessment_fail is None:
incomplete_list.append("Assessment")
if question_fail is not None:
if assessment_fail is None:
if question_fail == "Pass":
data_client.risk_level = "low"
else:
data_client.risk_level = "incomplete"
elif assessment_fail == "Fail":
if num_falls > 1:
data_client.risk_level = "high"
elif num_falls == 1:
# Unnecessary check but just in case
if injury:
data_client.risk_level = "high"
elif not injury:
data_client.risk_level = "moderate"
elif num_falls == 0:
data_client.risk_level = "moderate"
# Note that by just doing a FAT, and passing it, then you are low risk anyway
# The decision is made to return "incomplete" even if there's a pass for assessment and nothing
# for questions, since they are rather crucial to know about, and screening is fast.
elif assessment_fail == "Pass":
data_client.risk_level = "low"
data_client.observations[risk_code] = data_client.risk_level
data_client.fhir_client.write_list_of_observations_to_fhir(
data=data_client.observations)
return incomplete_list
def questions(request):
data_client = DataClient()
completed = get_sidebar_completed()
if request.method == 'POST':
question_form = QuestionForm(request.POST)
if question_form.is_valid():
score = 0
key_score = 0
for i, question in enumerate(data_client.questions['questions']):
code = data_client.questions['questions'][i]['code']
field_name = code
answer = question_form.cleaned_data[field_name]
data_client.observations[code] = answer
flag = False
# This could be fragile if changed to >=2 falls? Or something non 1
if isinstance(answer, int):
if answer >= 1:
flag = True
else:
flag = answer
if flag:
score += int(
data_client.questions['questions'][i]['score'])
if data_client.questions['questions'][i]['is_key']:
key_score += 1
questions_code = data_client.questions['code']
if (key_score < data_client.questions['question_logic']['min_key']
and score <
data_client.questions['question_logic']['min_score']):
data_client.observations[questions_code] = "Pass"
else:
data_client.observations[questions_code] = "Fail"
# save observations to FHIR server
data_client.fhir_client.write_list_of_observations_to_fhir(
data=data_client.observations)
if data_client.identity == 'patient':
return HttpResponseRedirect('/app/thankyou/')
else:
calculate_risk()
if data_client.risk_level == "incomplete":
return HttpResponseRedirect('/app/assessments/')
elif data_client.risk_level is not None:
return HttpResponseRedirect('/app/risks/')
else:
if (request.GET.get('patient') != None):
if (request.GET.get('encounter_id') != None):
data_client.fhir_client.select_encounter(
request.GET.get('encounter_id'))
data_client.observations = data_client.fhir_client.search_observations(
)
elif (request.GET.get('button_type') != None
and request.GET.get('button_type') == "start"):
data_client.reload_data()
data_client.fhir_client.create_new_encounter(
set_as_active_encounter=True)
data_client.patient = literal_eval(request.GET.get('patient'))
data_client.fhir_client.select_patient(
data_client.patient['resource']['id'])
question_answers = {}
for i, question in enumerate(data_client.questions['questions']):
code = data_client.questions['questions'][i]['code']
if code in data_client.observations:
code = data_client.questions['questions'][i]['code']
field_name = code
question_answers[field_name] = data_client.observations[code]
completed = get_sidebar_completed()
question_form = QuestionForm(initial=question_answers)
if data_client.identity == "patient":
extends_variable = getattr(settings, 'AUTHBACKEND_LAYOUT_TEMPLATE',
'app/base.html')
else:
extends_variable = getattr(settings, 'AUTHBACKEND_LAYOUT_TEMPLATE',
'app/baseWithSideBar.html')
return render(
request, 'app/questions.html', {
'question_form': question_form,
'patient': data_client.patient,
'identity': data_client.identity,
'extends_variable': extends_variable,
'completed': completed
})
def thankyou(request):
data_client = DataClient()
return render(request, 'app/thankyou.html',
{'patient': data_client.patient})
