def basicnote_detail(request, pk, model):
note = get_object_or_404(model, pk=pk)
active_role = get_active_role(request)
can_sign = False
can_update = False
attestable = (model == models.AttestableBasicNote)
title = ""
if attestable:
can_sign = note.group_can_sign(active_role)
can_update = group_has_perm(active_role,
'workup.change_attestablebasicnote')
title = "Attestable Basic Note"
else:
can_update = group_has_perm(active_role, 'workup.change_basicnote')
title = "Basic Note"
return render(
request, 'workup/basicnote_detail.html', {
'note': note,
'can_sign': can_sign,
'can_update': can_update,
'attestable': attestable,
'title': title
})
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
vai = get_object_or_404(VaccineActionItem, pk=self.kwargs['ai_id'])
vai.mark_done(self.request.user)
vai.save()
vai_fu = form.save(commit=False)
vai_fu.author = self.request.user
vai_fu.author_type = get_active_role(self.request)
vai_fu.action_item = vai
vai_fu.patient = pt
vai_fu.save()
form.save_m2m()
if 'followup_create' in self.request.POST:
return HttpResponseRedirect(
reverse('new-vaccine-ai',
kwargs={
'pt_id': pt.id,
'series_id': vai.vaccine.id
}))
else:
return HttpResponseRedirect(
reverse("core:patient-detail", args=(pt.id, )))
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
series = get_object_or_404(VaccineSeries, pk=self.kwargs['series_id'])
dose = form.save(commit=False)
# Assign author and author type
dose.author = self.request.user
dose.author_type = get_active_role(self.request)
dose.patient = pt
dose.series = series
dose.save()
form.save_m2m()
if dose.is_last():
return HttpResponseRedirect(
reverse('core:patient-detail', args=(pt.id, )))
else:
formatted_date = dose.next_due_date().strftime("%D")
querystr = '%s=%s' % ("due_date", formatted_date)
vai_url = "%s?%s" % (reverse('new-vaccine-ai',
kwargs={
'pt_id': pt.id,
'series_id': series.id
}), querystr)
return HttpResponseRedirect(vai_url)
def form_valid(self, form):
"""Set the patient, provider, and written timestamp, and status."""
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
referral = form.save(commit=False)
# Get referral type from the URL
rtype_slug = self.kwargs['rtype']
slugs = {
referral_type.slugify(): referral_type
for referral_type in ReferralType.objects.all()
}
rtype = slugs[rtype_slug]
referral.kind = get_object_or_404(ReferralType, name=rtype)
# Assign author and author type
referral.author = self.request.user
referral.author_type = get_active_role(self.request)
referral.patient = pt
referral.save()
form.save_m2m()
return HttpResponseRedirect(
reverse('new-followup-request', args=(
pt.id,
referral.id,
)))
def form_valid(self, form):
appointment = form.save(commit=False)
appointment.author = self.request.user
appointment.author_type = get_active_role(self.request)
appointment.save()
form.save_m2m()
return HttpResponseRedirect(reverse("appointment-list"))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
self.pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
context['pt'] = self.pt
context['labs'] = Lab.objects.filter(patient=self.kwargs['pt_id'])
active_role = get_active_role(self.request)
for perm in ['add_lab']:
context[perm] = group_has_perm(active_role, 'labs.%s' % perm)
return context
def get_context_data(self, **kwargs):
context = super(DrugListView, self).get_context_data(**kwargs)
context['patients'] = Patient.objects.filter(
needs_workup=True).order_by('last_name').select_related('gender')
active_role = get_active_role(self.request)
context['can_export_csv'] = group_has_perm(active_role,
'inventory.export_csv')
return context
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
followup_request = form.save(commit=False)
followup_request.author = self.request.user
followup_request.author_type = get_active_role(self.request)
followup_request.referral = get_object_or_404(
Referral, pk=self.kwargs['referral_id'])
followup_request.patient = pt
followup_request.save()
return HttpResponseRedirect(
reverse('core:patient-detail', args=(pt.id, )))
def get_context_data(self, **kwargs):
context = super(LabDetailView,self).get_context_data(**kwargs)
self.lab = get_object_or_404(Lab, pk=self.kwargs['pk'])
context['lab'] = self.lab
context['pt'] = self.lab.patient
measurement_list = get_measurements_from_lab(self.lab.id)
context['measurement_list'] = measurement_list
active_role = get_active_role(self.request)
for perm in ['change_lab']:
context[perm] = group_has_perm(active_role, 'labs.%s' % perm)
return context
def form_valid(self, form):
doc = form.save(commit=False)
pt = get_object_or_404(core_models.Patient, pk=self.kwargs['pt_id'])
doc.patient = pt
doc.author = self.request.user
doc.author_type = get_active_role(self.request)
doc.save()
return HttpResponseRedirect(
reverse("core:patient-detail", args=(pt.id, )))
def workup_detail(request, pk):
workup = get_object_or_404(models.Workup, pk=pk)
active_role = get_active_role(request)
can_sign = models.Workup.group_can_sign(active_role)
can_export_pdf = group_has_perm(active_role, 'workup.export_pdf_Workup')
return render(request, 'workup/workup_detail.html', {
'workup': workup,
'can_sign': can_sign,
'can_export_pdf': can_export_pdf
})
def patient_activate_home(request, pk):
pt = get_object_or_404(core_models.Patient, pk=pk)
active_role = get_active_role(request)
can_activate = pt.group_can_activate(active_role)
if can_activate:
pt.toggle_active_status(request.user, active_role)
pt.save()
return HttpResponseRedirect(reverse("home"))
def dashboard_dispatch(request):
"""Redirect an incoming user to the appropriate dashboard.
Falls back to the 'home' url.
"""
active_role = get_active_role(request)
dashboard_dispatch = settings.OSLER_ROLE_DASHBOARDS
if active_role.name in dashboard_dispatch:
return redirect(dashboard_dispatch[active_role.name])
else:
return redirect(settings.OSLER_DEFAULT_DASHBOARD)
def form_valid(self, form):
note = form.save(commit=False)
note.patient = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
note.author = self.request.user
active_role = get_active_role(self.request)
note.author_type = active_role
note.save()
form.save_m2m()
return HttpResponseRedirect(
reverse("core:patient-detail", args=(note.patient.id, )))
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
vai = form.save(commit=False)
vai.completion_date = None
vai.author = self.request.user
vai.author_type = get_active_role(self.request)
vai.vaccine = get_object_or_404(
VaccineSeries, pk=self.kwargs['series_id'])
vai.patient = pt
vai.save()
form.save_m2m()
return HttpResponseRedirect(reverse('core:patient-detail', args=(pt.id,)))
def check_active_perms(request):
active_role = get_active_role(request)
if isinstance(perm, str):
perms = (perm, )
else:
perms = perm
# First check if the user has the permission (even anon users)
if group_has_perms(active_role, perms):
return True
# In case the 403 handler should be called raise the exception
if raise_exception:
raise PermissionDenied
# As the last resort, show the login form
return False
def form_valid(self, form):
'''Set the patient, user, and written timestamp for the item.'''
pt = get_object_or_404(core_models.Patient, pk=self.kwargs['pt_id'])
ai = form.save(commit=False)
ai.completion_date = None
ai.author = self.request.user
ai.author_type = get_active_role(self.request)
ai.patient = pt
ai.save()
return HttpResponseRedirect(
reverse("core:patient-detail", args=(pt.id, )))
def sign_attestable_note(request, pk, attestable):
note = get_object_or_404(attestable, pk=pk)
active_role = get_active_role(request)
try:
note.sign(request.user, active_role)
note.save()
except ValueError:
# thrown exception can be ignored since we just redirect back to the
# workup detail view anyway
pass
return HttpResponseRedirect(note.get_absolute_url())
def dispatch(self, *args, **kwargs):
'''
Intercept dispatch for NoteUpdate and verify that the user has
permission to modify this Workup.
'''
active_role = get_active_role(self.request)
wu = get_object_or_404(models.Workup, pk=kwargs['pk'])
# if it's an attending, we allow updates.
if self.model.group_can_sign(active_role) or not wu.signed():
return super(WorkupUpdate, self).dispatch(*args, **kwargs)
else:
return HttpResponseRedirect(
reverse('workup', args=(kwargs['pk'], )))
def patient_activate_detail(request, pk, home=False):
'''Toggle status to default active/inactive'''
pt = get_object_or_404(core_models.Patient, pk=pk)
active_role = get_active_role(request)
can_activate = pt.group_can_activate(active_role)
if can_activate:
pt.toggle_active_status(request.user, active_role)
if home:
return HttpResponseRedirect(reverse("home"))
else:
return HttpResponseRedirect(
reverse("core:patient-detail", args=(pt.id, )))
def form_valid(self, form):
"""Set the patient, author, and written timestamp, and status."""
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
series = form.save(commit=False)
# Assign author and author type
series.author = self.request.user
series.author_type = get_active_role(self.request)
series.patient = pt
series.save()
form.save_m2m()
return HttpResponseRedirect(reverse('new-vaccine-dose',
kwargs={'pt_id': pt.id,'series_id': series.id}))
def form_valid(self, form):
note = form.save(commit=False)
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
note.patient = pt
note.author = self.request.user
active_role = get_active_role(self.request)
note.author_type = active_role
if models.AttestableBasicNote.group_can_sign(active_role):
note.sign(self.request.user, active_role)
note.save()
form.save_m2m()
return HttpResponseRedirect(
reverse("core:patient-detail", args=(note.patient.id, )))
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
active_role = get_active_role(self.request)
wu = form.save(commit=False)
wu.patient = pt
wu.author = self.request.user
wu.author_type = active_role
if not wu.is_pending and self.model.group_can_sign(active_role):
wu.sign(self.request.user, active_role)
wu.save()
form.save_m2m()
return HttpResponseRedirect(
reverse("core:patient-detail", args=(pt.id, )))
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
ai = get_object_or_404(ActionItem, pk=self.kwargs['ai_id'])
ai_fu = form.save(commit=False)
ai_fu.author = self.request.user
ai_fu.author_type = get_active_role(self.request)
ai_fu.action_item = ai
ai_fu.patient = pt
ai_fu.save()
form.save_m2m()
if 'followup_create' in self.request.POST:
return HttpResponseRedirect(reverse('core:new-action-item',
args=(pt.id,)))
else:
return HttpResponseRedirect(reverse("core:patient-detail",
args=(pt.id,)))
def drug_dispense(request):
pk = request.POST['pk']
num = request.POST['num']
patient_pk = request.POST['patient_pk']
drug = models.Drug.objects.get(pk=pk)
patient = Patient.objects.get(pk=patient_pk)
can_dispense = drug.can_dispense(int(num))
if can_dispense:
models.DispenseHistory.objects.create(
drug=drug,
dispense=num,
author=request.user,
author_type=get_active_role(request),
patient=patient)
drug.dispense(int(num))
else:
return HttpResponseNotFound(
'<h1>Cannot dispense more drugs than in stock!</h1>')
return redirect('inventory:drug-list')
def form_valid(self, form):
note = form.save(commit=False)
note.workup = get_object_or_404(models.Workup, pk=self.kwargs['wu_id'])
note.patient = note.workup.patient
note.author = self.request.user
if int(self.kwargs['pt_id']) != note.patient.id:
return HttpResponseServerError(
'Patient associated with workup does not match supplied patient primary key.'
)
active_role = get_active_role(self.request)
note.author_type = active_role
note.save()
form.save_m2m()
return HttpResponseRedirect(
reverse("workup", args=(self.kwargs['wu_id'], )))
def form_valid(self, form):
pt = get_object_or_404(Patient, pk=self.kwargs['pt_id'])
referral = get_object_or_404(Referral, pk=self.kwargs['referral_id'])
followup_request = get_object_or_404(FollowupRequest,
pk=self.kwargs['followup_id'])
# Add completion date to followup request
followup_request.mark_done(self.request.user)
followup_request.save()
patient_contact = form.save(commit=False)
# Fill in remaining fields of form
patient_contact.author = self.request.user
patient_contact.author_type = get_active_role(self.request)
patient_contact.referral = referral
patient_contact.patient = pt
patient_contact.followup_request = followup_request
patient_contact.save()
form.save_m2m()
# Redirect to appropriate page and update referral status
if PatientContactForm.SUCCESSFUL_REFERRAL in self.request.POST:
referral.status = Referral.STATUS_SUCCESSFUL
referral.save()
return HttpResponseRedirect(
reverse('core:patient-detail', args=(pt.id, )))
elif PatientContactForm.REQUEST_FOLLOWUP in self.request.POST:
referral.status = Referral.STATUS_PENDING
referral.save()
return HttpResponseRedirect(
reverse('new-followup-request', args=(
pt.id,
referral.id,
)))
elif PatientContactForm.UNSUCCESSFUL_REFERRAL in self.request.POST:
referral.status = Referral.STATUS_UNSUCCESSFUL
referral.save()
return HttpResponseRedirect(
reverse('core:patient-detail', args=(pt.id, )))
def patient_detail(request, pk):
pt = get_object_or_404(core_models.Patient, pk=pk)
# Special zipped list of action item types so they can be looped over.
# List 1: Labels for the panel objects of the action items
# List 2: Action Item lists based on type (active, pending, completed)
# List 3: Title labels for the action items
# List 4: True and False determines if the link should be for
# done_action_item or update_action_item
active_ais = []
inactive_ais = []
done_ais = []
# Add action items for apps that are turned on in Osler's base settings
# OSLER_TODO_LIST_MANAGERS contains app names like referral which contain
# tasks for clinical teams to carry out (e.g., followup with patient)
for app, model in settings.OSLER_TODO_LIST_MANAGERS:
ai = apps.get_model(app, model)
active_ais.extend(ai.objects.get_active(patient=pt))
inactive_ais.extend(ai.objects.get_inactive(patient=pt))
done_ais.extend(ai.objects.get_completed(patient=pt))
# Calculate the total number of action items for this patient,
# This total includes all apps that that have associated
# tasks requiring clinical followup (e.g., referral followup request)
total_ais = len(active_ais) + len(inactive_ais) + len(done_ais)
zipped_ai_list = list(
zip(['collapse8', 'collapse9', 'collapse10'],
[active_ais, inactive_ais, done_ais], [
'Active Action Items', 'Pending Action Items',
'Completed Action Items'
], [True, True, False]))
# Provide referral list for patient page (includes specialty referrals)
referrals = Referral.objects.filter(
patient=pt, followuprequest__in=FollowupRequest.objects.all())
# Add FQHC referral status
# Note it is possible for a patient to have been referred multiple times
# This creates some strage cases (e.g., first referral was lost to followup
# but the second one was successful). In these cases, the last referral
# status becomes the current status
fqhc_referrals = Referral.objects.filter(patient=pt, kind__is_fqhc=True)
referral_status_output = Referral.aggregate_referral_status(fqhc_referrals)
# Pass referral follow up set to page
referral_followups = PatientContact.objects.filter(patient=pt)
#Pass vaccine follow up set to page
vaccine_followups = VaccineFollowup.objects.filter(patient=pt)
total_followups = referral_followups.count() + len(
pt.followup_set()) + vaccine_followups.count()
appointments = Appointment.objects \
.filter(patient=pt) \
.order_by('clindate', 'clintime')
# d = collections.OrderedDict()
# for a in appointments:
# if a.clindate in d:
# d[a.clindate].append(a)
# else:
# d[a.clindate] = [a]
future_date_appointments = appointments.filter(
clindate__gte=datetime.date.today()).order_by('clindate', 'clintime')
previous_date_appointments = appointments.filter(
clindate__lt=datetime.date.today()).order_by('-clindate', 'clintime')
future_apt = collections.OrderedDict()
for a in future_date_appointments:
if a.clindate in future_apt:
future_apt[a.clindate].append(a)
else:
future_apt[a.clindate] = [a]
previous_apt = collections.OrderedDict()
for a in previous_date_appointments:
if a.clindate in previous_apt:
previous_apt[a.clindate].append(a)
else:
previous_apt[a.clindate] = [a]
zipped_apt_list = list(
zip(['collapse11', 'collapse12'],
[future_date_appointments, previous_date_appointments],
['Future Appointments', 'Past Appointments'],
[future_apt, previous_apt]))
# Permissions to display things on patient-detail, just toggle active status for now
# But I think this way vs in the html will make it easier to add/change later
active_role = get_active_role(request)
can_activate = pt.group_can_activate(active_role)
can_case_manage = group_has_perm(active_role, 'core.case_manage_Patient')
can_export_pdf = group_has_perm(active_role, 'workup.export_pdf_Workup')
context = {
'zipped_ai_list': zipped_ai_list,
'total_ais': total_ais,
'referral_status': referral_status_output,
'referrals': referrals,
'referral_followups': referral_followups,
'vaccine_followups': vaccine_followups,
'total_followups': total_followups,
'patient': pt,
'appointments_by_date': future_apt,
'zipped_apt_list': zipped_apt_list,
'can_activate': can_activate,
'can_case_manage': can_case_manage,
'can_export_pdf': can_export_pdf
}
return render(request, 'core/patient_detail.html', context)
def view_all_as_table(request,pt_id,month_range=6):
"""
Lab table view with recent labs
A table with rows as measurement values and columns as labs
Displays recent labs
"""
if request.method == 'GET' and 'select' in request.GET:
month_range = int(request.GET['select'])
# Get qs for the patient
pt = get_object_or_404(Patient, id=pt_id)
lab_types = list(LabType.objects.all())
to_tz = timezone.get_default_timezone()
time_threshold = datetime.now(to_tz) - timedelta(days=month_range*31)
lab_qs = Lab.objects.filter(patient=pt_id, lab_time__gt=time_threshold)
lab_days = sorted([lab.get_day() for lab in lab_qs], reverse=True)
unique_lab_days=reduce(lambda l, x: l if x in l else l+[x], lab_days, [])
listed_lab_days = unique_lab_days[:]
n_days = len(listed_lab_days)
# Initiate empty table
# width = # of labs
# height = # of measurement types
table_header = ['','Reference']
col_header_len = len(table_header)
table_header += [ str(x) for x in listed_lab_days ]
table_content = []
sorted_measure_types = []
dup_lab_bool = False
for t_lab_type in lab_types:
m_types = get_measurementtypes_from_labtype(t_lab_type.id)
table_content.append([table_header[:]])
table_content[-1][0][0] = ('Lab Category: '+str(t_lab_type))
sorted_measure_types.append([])
for mt in m_types:
table_content[-1].append(([mt, mt.get_ref()] + ['']*n_days))
sorted_measure_types[-1].append(mt)
# Fill in entries
for t_lab in lab_qs.reverse():
if (not (t_lab.get_day() in listed_lab_days)):
continue
measurements = get_measurements_from_lab(t_lab.id)
col_index = listed_lab_days.index(t_lab.get_day()) + col_header_len
for m in measurements:
section_index = lab_types.index(t_lab.lab_type)
m_type = m.measurement_type
row_index = (sorted_measure_types[section_index]).index(m_type)
current_value = table_content[section_index][row_index+1][col_index]
if current_value=='':
table_content[section_index][row_index+1][col_index] = m
else:
table_content[section_index][row_index+1][col_index] = m
table_content[section_index][0][col_index] += '*'
dup_lab_bool = True
qs = {'patient':pt,
'table_content': table_content,
'add_lab': group_has_perm(get_active_role(request), 'labs.add_lab'),
'no_lab_bool':len(lab_qs)==0,
'dup_lab_bool': dup_lab_bool}
return render(request, 'labs/lab_all_table.html', qs)
