def batch_unassign(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
except (GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
batch_queryset = group.get_patients()
else:
batch_queryset = request.user.professional_profile.get_patients()
return generic_form(
request,
form_class=BatchUnassignPatientForm,
page_title='Assign Patients',
system_message="The patients have been unassigned.",
batch=True,
go_back_until=[
'accounts:manage-patients', 'accounts:manage-groups-patients'],
only_batch_input=True,
batch_queryset=batch_queryset
)
def add(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
page_title = "Add Payor/TPA for %s" % group
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
page_title = "Add Payor/TPA"
except (GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Payors',
reverse('accounts:manage-groups-payors', args=[group.pk]))
]
else:
breadcrumbs = []
return generic_form(request,
form_class=PayorForm,
page_title=page_title,
system_message="The payor/TPA has been created.",
breadcrumbs=breadcrumbs,
form_kwargs={'initial_group': group})
def compliance_data(request, user_id):
try:
patient = request.user.professional_profile.get_patients().get(
pk=user_id)
except User.DoesNotExist as e:
return debug_response(e)
today = utcnow().astimezone(request.user.professional_profile.timezone)
readings = []
labels = []
for i in range(7, 0, -1):
timezone = request.user.professional_profile.timezone
cur_datetime = convert_date_to_utc_datetime(today - timedelta(days=i),
timezone)
end_datetime = cur_datetime + timedelta(days=1)
readings.append(
patient.glucose_readings.filter(
reading_datetime_utc__range=(cur_datetime,
end_datetime)).count())
labels.append(cur_datetime.strftime('%a'))
data = {
'labels': labels,
'readings': readings,
'patient_name': patient.get_full_name(),
'professional_name': request.user.get_full_name()
}
data['date_range'] = '%s - %s' % (
(today - timedelta(days=7)).strftime('%m/%d/%y'),
(today - timedelta(days=1)).strftime('%m/%d/%y'))
return HttpResponse(json.dumps(data), content_type="application/json")
def import_csv(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
except (AssertionError, GenesisGroup.DoesNotExist) as e:
return debug_response(e)
if request.user.is_admin():
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Professionals',
reverse('accounts:manage-groups-professionals',
args=[group.pk]))
]
else:
breadcrumbs = []
return generic_form(request,
form_class=ImportProfessionalForm,
form_kwargs={
'requester': request.user,
'initial_group': group
},
page_title='Import Professional',
breadcrumbs=breadcrumbs,
system_message='The professionals have been imported')
def import_devices(request, group_id=None):
group = None
if group_id:
try:
group = GenesisGroup.objects.get(pk=group_id)
except GenesisGroup.DoesNotExist as e:
return debug_response(e)
else:
form_kwargs = {'group': group}
else:
form_kwargs = {}
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb('Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb('Devices'.format(group.name),
reverse('accounts:manage-groups-devices', args=[group.pk])),
]
return generic_form(request,
page_title='Import Devices',
form_class=ImportDevicesForm,
form_kwargs=form_kwargs,
breadcrumbs=breadcrumbs,
system_message='The devices have been imported.')
def edit(request, patient_id=None, group_id=None):
try:
if patient_id:
assert request.user.is_professional()
patient = request.user.professional_profile.get_patients().get(
pk=patient_id)
else:
assert request.user.is_patient()
patient = request.user
except (User.DoesNotExist, AssertionError) as e:
return debug_response(e)
try:
hi = HealthInformation.objects.get(patient=patient)
except HealthInformation.DoesNotExist:
hi = HealthInformation(patient=patient)
message = '%s health information has been updated.' % (
request.user.is_patient() and 'Your' or 'The patient\'s')
return generic_form(request,
form_class=HealthInformationForm,
page_title='Edit Health Targets',
system_message=message,
go_back_until=[
'edit-health-information-for-patient',
'edit-health-information'
],
form_kwargs={'instance': hi})
def edit(request, patient_id, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
patient = group.get_patients().get(pk=patient_id)
else:
if request.user.is_professional():
group = request.user.professional_profile.parent_group
patient = request.user.professional_profile.get_patients(
['edit-patient-profile']).get(pk=patient_id)
else:
patient = PatientProfile.myghr_patients.get_users().get(
pk=patient_id)
group = patient.patient_profile.get_group()
except (GenesisGroup.DoesNotExist, User.DoesNotExist, AssertionError) as e:
return debug_response(e)
breadcrumbs = get_patient_breadcrumbs(patient, request.user)
return generic_form(
request,
form_class=PatientForm,
page_title='Edit Patient {}'.format(patient.get_reversed_name()),
system_message="The patient has been updated.",
form_kwargs={'initial_group': group, 'instance': patient},
breadcrumbs=breadcrumbs)
def batch_assign(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
except (GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
batch_queryset = group.get_patients()
else:
batch_queryset = request.user.professional_profile.get_patients()
return generic_form(
request,
form_class=BatchAssignPatientForm,
page_title='Assign Patients',
system_message="The patients have been assigned.",
form_kwargs={'professionals': group.get_professionals()},
batch=True,
batch_queryset=batch_queryset
)
def logbook_get_notes_for_period(request):
try:
for i in ('start_time', 'end_time', 'patient_id'):
assert request.POST.get(i)
patient_id = int(request.POST.get('patient_id'))
if request.user.is_admin():
patient = PatientProfile.myghr_patients.get_users().get(
pk=patient_id)
elif request.user.is_professional():
patient = request.user.get_profile().get_patients().get(
pk=patient_id)
else:
assert request.user.pk == patient_id
patient = request.user
except (AssertionError, User.DoesNotExist) as e:
return debug_response(e)
format = "%Y-%m-%d %I:%M %p"
timezone = patient.patient_profile.timezone
local_start_datetime = timezone.localize(
datetime.strptime(request.POST.get('start_time'), format))
local_end_datetime = timezone.localize(
datetime.strptime(request.POST.get('end_time'), format))
start_datetime = local_start_datetime.astimezone(pytz.utc)
end_datetime = local_end_datetime.astimezone(pytz.utc)
entries = patient.glucose_readings.filter(
reading_datetime_utc__range=(start_datetime, end_datetime))
notes = GlucoseReadingNote.objects.filter(entry__in=entries)
return render(request, 'reports/logbook/notes.html', {'notes': notes})
def records(request, patient_id):
try:
patient = request.user.professional_profile.get_patients().get(
pk=patient_id)
except User.DoesNotExist as e:
return debug_response(e)
c = {'patient': patient}
return render(request, 'accounts/manage/records.html', c)
def edit(request, alert_id):
try:
alert = request.user.get_profile().get_alerts().get(pk=alert_id)
except PatientAlert.DoesNotExist as e:
return debug_response(e)
return generic_form(request,
form_class=PatientAlertForm,
page_title='Edit Alert',
system_message='The alert has been updated.',
form_kwargs={
'requester': request.user,
'instance': alert
},
extra_head_template='alerts/js/edit.html')
def edit_targets(request, patient_id):
try:
patient = request.user.professional_profile.get_patients().get(
pk=patient_id)
targets = HealthProfessionalTargets.objects.get_or_create(
patient=patient, professional=request.user)
except (User.DoesNotExist, HealthProfessionalTargets.DoesNotExist) as e:
return debug_response(e)
return generic_form(
request,
form_class=HealthProfessionalTargetsForm,
page_title='Edit Health Targets for %s' % patient.get_reversed_name(),
system_message='The patient\'s targets have been updated.',
form_kwargs={'instance': targets})
def assign(request, device_id):
try:
if request.user.is_professional():
device = request.user.professional_profile.\
parent_group.gdrives.get(pk=device_id)
else:
device = GDrive.objects.get(pk=device_id)
except GDrive.DoesNotExist as e:
return debug_response(e)
return generic_form(request,
form_class=AssignDeviceForm,
form_kwargs={'instance': device},
page_title="Assign Device %s to a Patient" %
device.meid,
system_message="The device has been assigned.")
def logbook_entry(request, entry_id):
try:
instance = GlucoseReading.objects.get(pk=entry_id)
except GlucoseReading.DoesNotExist as e:
return debug_response(e)
form = GlucoseReadingEntryForm(requester=request.user, instance=instance)
form_url = reverse('reports:ajax-logbook-entry-update',
kwargs={'entry_id': entry_id})
return render(request, 'reports/logbook/entry.html', {
'instance': instance,
'form': form,
'form_url': form_url
})
def logbook_entry_update(request, entry_id):
try:
instance = GlucoseReading.objects.get(pk=entry_id)
except GlucoseReading.DoesNotExist as e:
return debug_response(e)
form = GlucoseReadingEntryForm(request.POST,
instance=instance,
requester=request.user)
success = form.is_valid()
c = {'success': success}
if success:
form.save()
else:
c['errors'] = form.errors
return HttpResponse(json.dumps(c), content_type='application/json')
def edit(request, user_id, group_id=None):
group = None
user = None
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
user = group.get_professionals().get(pk=user_id)
else:
if request.user.is_admin():
user = ProfessionalProfile.objects.get_users().get(pk=user_id)
group = user.professional_profile.parent_group
elif request.user.is_professional():
group = request.user.professional_profile.parent_group
user = group.get_professionals().get(pk=user_id)
except (User.DoesNotExist, GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Professionals',
reverse('accounts:manage-groups-professionals',
args=[group.pk])),
Breadcrumb(
'Professional: {0}'.format(user.get_reversed_name()),
reverse('accounts:manage-professionals-detail',
args=[user.pk]))
]
else:
breadcrumbs = []
return generic_form(request,
breadcrumbs=breadcrumbs,
form_class=ProfessionalForm,
form_kwargs={
'requester': request.user,
'initial_group': group,
'instance': user
},
page_title='Edit Professional',
system_message='The professional has been updated.')
def delete(request, device_id):
try:
if request.user.is_professional():
group = request.user.professional_profile.parent_group
device = group.gdrives.get(pk=device_id)
else:
device = GDrive.objects.get(pk=device_id)
group = device.group
except GDrive.DoesNotExist as e:
return debug_response(e)
if request.user.is_admin():
if group:
breadcrumbs = [
Breadcrumb('Business Partners',
reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Devices'.format(group.name),
reverse('accounts:manage-groups-devices',
args=[group.pk])),
]
else:
breadcrumbs = [Breadcrumb('Devices', reverse('gdrives:index'))]
else:
breadcrumbs = []
if device.readings.count() > 0:
extra_delete_warning = (
'Note: This device has readings associated with it. If you '
'delete it, the readings will have no device associated '
'with them.')
else:
extra_delete_warning = None
return generic_delete_form(request,
device,
breadcrumbs=breadcrumbs,
go_back_until=[
'gdrives:index',
'accounts:manage-groups-devices',
'gdrives:patient-details'
],
extra_delete_warning=extra_delete_warning)
def unassign(request, device_id):
try:
if request.user.is_professional():
device = request.user.professional_profile.\
parent_group.get_devices(group_only=True).get(pk=device_id)
else:
device = GDrive.objects.get(pk=device_id)
assert device.patient is not None
patient = device.patient
except (GDrive.DoesNotExist, AssertionError) as e:
return debug_response(e)
device.unregister()
return redirect_with_message(
request, reverse('gdrives:patient-details', args=[patient.pk]),
'The device has been unassigned.', ['gdrives:detail'])
def batch_delete(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
except (GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
return generic_delete_form(
request,
system_message='The selected payors have been deleted.',
batch_queryset=group.payors.all(),
batch=True,
)
def update_note(request, patient_id, note_id=None):
form_kwargs = {'requester': request.user}
try:
form_kwargs['patient'] = \
request.user.professional_profile.get_patients().get(pk=patient_id)
if note_id:
form_kwargs['instance'] = note = Note.objects.get(pk=note_id)
assert note.author == request.user
except (User.DoesNotExist, AssertionError, Note.DoesNotExist) as e:
return debug_response(e)
return generic_form(
request,
form_class=UpdateNotesForm,
form_kwargs=form_kwargs,
system_message="Your note has been added.",
go_back_until=['accounts:manage-patients-notes']
)
def edit(request, payor_id, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
else:
if request.user.is_admin():
group = None
else:
group = request.user.professional_profile.parent_group
if group:
payor = group.payors.get(pk=payor_id)
else:
payor = Payor.objects.get(pk=payor_id)
if not group:
group = payor.group
except (GenesisGroup.DoesNotExist, Payor.DoesNotExist,
AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Payors',
reverse('accounts:manage-groups-payors', args=[group.pk])),
Breadcrumb('Payor: {0}'.format(payor.name), '')
]
else:
breadcrumbs = []
return generic_form(request,
form_class=PayorForm,
page_title='Edit %s' % payor,
system_message="The payor/TPA has been updated.",
breadcrumbs=breadcrumbs,
form_kwargs={
'instance': payor,
'initial_group': group
})
def notes(request, patient_id):
form_kwargs = {'requester': request.user}
try:
form_kwargs['patient'] = patient = \
request.user.professional_profile.get_patients().get(pk=patient_id)
except User.DoesNotExist as e:
try:
form_kwargs['patient'] = patient = \
request.user.professional_profile.watch_list.get(user__pk=patient_id).user
except User.DoesNotExist as e:
return debug_response(e)
c = {
'patient': patient,
'form': UpdateNotesForm(**form_kwargs),
'notes': patient.notes_about.order_by('-date_created')
}
return render(request, 'accounts/manage/notes.html', c)
def assign_to_patient(request, device_id, patient_id):
try:
if request.user.is_professional():
patient = request.user.professional_profile.\
get_patients().get(pk=patient_id)
device = request.user.professional_profile.\
parent_group.get_available_devices(patient, True).get(
pk=device_id)
else:
device = GDrive.objects.get(pk=device_id)
patient = PatientProfile.myghr_patients.get_users().get(
pk=patient_id)
except (GDrive.DoesNotExist, User.DoesNotExist) as e:
return debug_response(e)
patient.patient_profile.register_device(device)
return redirect_with_message(
request, reverse('gdrives:patient-details', args=[patient.pk]),
'The device has been assigned.', ['gdrives:detail'])
def edit(request, device_id):
try:
if request.user.is_professional():
group = request.user.professional_profile.parent_group
device = group.gdrives.get(pk=device_id)
else:
device = GDrive.objects.get(pk=device_id)
group = device.group
except GDrive.DoesNotExist as e:
return debug_response(e)
if request.user.is_admin():
if group:
breadcrumbs = [
Breadcrumb('Business Partners',
reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Devices'.format(group.name),
reverse('accounts:manage-groups-devices',
args=[group.pk])),
]
else:
breadcrumbs = [Breadcrumb('Devices', reverse('gdrives:index'))]
else:
breadcrumbs = []
return generic_form(request,
form_class=GDriveForm,
page_title='Edit Device',
system_message='The device has been updated.',
form_kwargs={
'instance': device,
'initial_group': group
},
breadcrumbs=breadcrumbs,
delete_view_args=[device.id])
def new(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
else:
if request.user.is_professional():
group = request.user.professional_profile.parent_group
else:
group = None
except (GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
if group:
breadcrumbs = [
Breadcrumb('Business Partners',
reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Devices'.format(group.name),
reverse('accounts:manage-groups-devices',
args=[group.pk])),
]
else:
breadcrumbs = [
Breadcrumb('New Devices', reverse('gdrives:new-devices'))
]
else:
breadcrumbs = []
return generic_form(request,
form_class=GDriveForm,
form_kwargs={'initial_group': group},
page_title='Add Device',
breadcrumbs=breadcrumbs,
system_message='The device has been created.')
def add(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(pk=group_id)
thanks_view_name = reverse('accounts:manage-groups-professionals',
args=[group.id])
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
thanks_view_name = reverse('accounts:manage-professionals')
except (GenesisGroup.DoesNotExist, AssertionError) as e:
return debug_response(e)
if request.user.is_admin():
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Professionals',
reverse('accounts:manage-groups-professionals',
args=[group.pk]))
]
else:
breadcrumbs = []
return generic_form(request,
form_class=ProfessionalForm,
form_kwargs={
'requester': request.user,
'initial_group': group
},
page_title='Add Professional',
thanks_view_name=thanks_view_name,
breadcrumbs=breadcrumbs,
system_message='The professional has been added.')
def logbook(request):
try:
form = DisplayLogbookForm(request.GET)
assert form.is_valid(), repr(form.errors)
data = form.cleaned_data
patient = data.get('patient')
if request.user.is_patient():
assert request.user == patient
elif request.user.is_professional():
assert patient in request.user.professional_profile.get_patients()
except AssertionError as e:
return debug_response(e)
days = LogbookDay.generate_logbook_days(**data)
return render(request,
'reports/logbook/day.json', {
'days': days,
'timezone': patient.patient_profile.timezone_name
},
content_type='application/javascript')
def import_csv_old(request, group_id=None):
try:
if group_id:
assert request.user.is_admin()
group = GenesisGroup.objects.get(id=group_id)
else:
assert request.user.is_professional()
group = request.user.professional_profile.parent_group
except (AssertionError, GenesisGroup.DoesNotExist) as e:
return debug_response(e)
if request.user.is_admin():
breadcrumbs = get_group_breadcrumbs(group, request.user)
breadcrumbs.append(
Breadcrumb(
'Patients'.format(group.name),
reverse('accounts:manage-groups-patients',
args=[group.pk]))
)
else:
breadcrumbs = [
Breadcrumb(
'Patients'.format(group.name),
reverse('accounts:manage-patients'))
]
view_kwargs = {
"form_class": ImportPatientForm,
"form_kwargs": {'initial_group': group, 'user': request.user},
"page_title": "Import Patients",
"system_message": "The patients have been imported.",
"go_back_until": ['accounts:manage-groups-patients'],
"breadcrumbs": breadcrumbs
}
if request.user.is_admin():
view_kwargs['send_download_url'] = True
return generic_form(request, **view_kwargs)
def manage_login(request, user_id): # REFACTOR
try:
user = User.objects.get(id=user_id)
except User.DoesNotExist as e: # pragma: no cover
return debug_response(e)
form_classes = {
'change_username': AdminChangeUsernameForm,
'check_security_question': AdminCheckSecurityQuestionForm,
'change_password': AdminChangePasswordForm,
'set_default_password_form': AdminSetDefaultPasswordForm
}
forms = {}
form_kwargs = {'instance': user}
if request.method == 'POST':
form_class = form_classes[request.POST['form_name']]
form = form_class(request.POST, **form_kwargs)
if form.is_valid():
form.save()
form_success_messages = {
'change_username':
'******'s username has been updated.',
'check_security_question':
'The user\'s security question has '
'been answered correctly.',
'change_password':
'******'s password has been updated.',
'set_default_password_form':
'The user\'s password has been updated.'
}
message = form_success_messages[request.POST['form_name']]
return redirect_with_message(
request,
None,
message,
go_back_until=['accounts:manage-login'])
forms[request.POST['form_name']] = form
cj = filter(lambda x: x[1] != form_class, form_classes.items())
for other_form_name, other_form_class in cj:
forms[other_form_name] = other_form_class(**form_kwargs)
else:
for form_name, form_class in form_classes.items():
forms[form_name] = form_class(**form_kwargs)
if user.is_patient():
group = user.patient_profile.get_group()
if group:
breadcrumbs = [
Breadcrumb('Business Partners',
reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Patients'.format(group.name),
reverse('accounts:manage-groups-patients',
args=[group.pk]))
]
else:
breadcrumbs = [
Breadcrumb('Users', reverse('accounts:manage-users'))
]
breadcrumbs.append(
Breadcrumb(
'Patient: {0}'.format(user.get_reversed_name()),
reverse('accounts:manage-patients-detail', args=[user.pk])))
else:
group = user.professional_profile.parent_group
breadcrumbs = [
Breadcrumb('Business Partners', reverse('accounts:manage-groups')),
Breadcrumb(
'Business Partner: {0}'.format(group.name),
reverse('accounts:manage-groups-detail', args=[group.pk])),
Breadcrumb(
'Professionals'.format(group.name),
reverse('accounts:manage-groups-professionals',
args=[group.pk])),
Breadcrumb(
'Professional: {0}'.format(user.get_reversed_name()),
reverse('accounts:manage-professionals-detail',
args=[user.pk]))
]
ctx = {
'target_user': user,
'forms': forms,
'breadcrumbs': breadcrumbs,
'new_password': make_password(user)
}
return render(request, 'accounts/manage_login.html', ctx)
def trend_report_average_data(request, patient_id):
try:
if request.user.is_professional():
patient = request.user.professional_profile.get_patients().get(
pk=patient_id)
elif request.user.is_patient():
assert request.user.id == int(patient_id)
patient = request.user
else:
patient = PatientProfile.myghr_patients.get_users().get(
pk=patient_id)
except (AssertionError, User.DoesNotExist) as e:
return debug_response(e)
form = ReportForm(request.GET)
if not form.is_valid():
return HttpResponse(repr(form.errors), status=500)
timezone = patient.patient_profile.timezone
local_start_datetime = timezone.localize(
datetime.combine(form.get_date("start_date"), time()))
local_end_datetime = timezone.localize(
datetime.combine(form.get_date("end_date"),
time())).astimezone(pytz.utc)
# Offset it to get all readings for that day
local_end_datetime += (timedelta(days=1) - timedelta(microseconds=1))
start_datetime = local_start_datetime.astimezone(pytz.utc)
end_datetime = local_end_datetime.astimezone(pytz.utc)
readings = GlucoseReading.objects.filter(
patient=patient,
reading_datetime_utc__range=[start_datetime, end_datetime])
readings = readings.exclude(
measure_type="TEST mode").order_by("reading_datetime_utc")
if form.cleaned_data.get('type') == 'premeal':
readings = readings.filter(
measure_type=GlucoseReading.MEASURE_TYPE_BEFORE)
glucose_goal = (patient.healthinformation.premeal_glucose_goal_minimum,
patient.healthinformation.premeal_glucose_goal_maximum)
elif form.cleaned_data.get('type') == 'postmeal':
readings = readings.filter(
measure_type=GlucoseReading.MEASURE_TYPE_AFTER)
glucose_goal = (
patient.healthinformation.postmeal_glucose_goal_minimum,
patient.healthinformation.postmeal_glucose_goal_maximum)
else:
glucose_goal = (
patient.healthinformation.premeal_glucose_goal_minimum,
patient.healthinformation.postmeal_glucose_goal_maximum)
total_readings = readings.count()
bottom, top = glucose_goal
chart_data = {
"above_count":
0,
"below_count":
0,
"within_count":
0,
"hypo_count":
0,
"hyper_count":
0,
"glucose_goal":
"%s-%s" % (bottom, top),
"patient_name":
patient.get_full_name(),
"date_range":
"%s - %s" %
(local_start_datetime.strftime('%m/%d/%y'),
(local_end_datetime - timedelta(days=1)).strftime('%m/%d/%y'))
}
# If viewing another report, send along the viewer's name.
if request.user.is_professional():
chart_data['professional_name'] = '%s (%s) (User: %s)' % (
request.user.get_full_name(),
request.user.professional_profile.parent_group,
request.user.username)
for r in readings:
if r.glucose_value > top:
chart_data["above_count"] += 1
if r.glucose_value > patient.healthinformation.safe_zone_maximum:
chart_data['hyper_count'] += 1
elif r.glucose_value < bottom:
chart_data["below_count"] += 1
if r.glucose_value < patient.healthinformation.safe_zone_minimum:
chart_data['hypo_count'] += 1
elif bottom <= r.glucose_value <= top:
chart_data["within_count"] += 1
chart_data["above_percentage"] = "%.2f" % (total_readings != 0 and (
(float(chart_data["above_count"]) / float(total_readings)) * 100) or 0)
chart_data["below_percentage"] = "%.2f" % (total_readings != 0 and (
(float(chart_data["below_count"]) / float(total_readings)) * 100) or 0)
chart_data["within_percentage"] = "%.2f" % (total_readings != 0 and (
(float(chart_data["within_count"]) / float(total_readings)) * 100)
or 0)
chart_data['hypo_percentage'] = "%.2f" % (total_readings != 0 and (
(float(chart_data["hypo_count"]) / float(total_readings)) * 100) or 0)
chart_data['hyper_percentage'] = "%.2f" % (total_readings != 0 and (
(float(chart_data["hyper_count"]) / float(total_readings)) * 100) or 0)
return HttpResponse(json.dumps(chart_data),
content_type="application/json")
