def get(self, request):
oauth_provider = get_object_or_404(UserSocialAuth, provider='drchrono')
access_token = oauth_provider.extra_data['access_token']
patient_client = PatientEndpoint(access_token)
patient = patient_client.fetch(request.GET.get('patient_id'))
return render(request, 'demographics.html',
{'form': DemographicForm(initial=patient), 'patient_id': request.GET.get('patient_id')})
def get_patient(self, patient_id):
"""
Load a patient by id
"""
access_token = self.get_token()
api = PatientEndpoint(access_token)
return api.fetch(patient_id)
def form_valid(self, form):
patients_api = PatientEndpoint(self.request.session["access_token"])
try:
patients_api.update(self.request.session["patient_id"],
form.cleaned_data)
except APIException:
return render(
self.request,
"patient_checkin.html",
{
"error": "There was an error updating your information",
"form": form
},
)
appointments_api = AppointmentEndpoint(
self.request.session["access_token"])
for appointment_id in self.request.session["appointment_ids"]:
try:
appointments_api.update(appointment_id, {"status": "Arrived"})
except APIException:
return render(
self.request,
"patient_checkin.html",
{
"error":
"There was an error checking in to your appointment",
"form": form,
},
)
appointment = Appointment.objects.get(api_id=appointment_id)
appointment.status = "Arrived"
appointment.check_in_time = timezone.now()
appointment.save()
return super(PatientDemographicsView, self).form_valid(form)
def fetch_a_patient(self, id='None'):
"""
Fetch a patient using ID, return the result
"""
access_token = self.get_token()
api = PatientEndpoint(access_token)
return api.fetch(id)
def make_api_request(self):
"""
Use the token we have stored in the DB to make an API request and get
doctor details. If this succeeds, we've proved that the OAuth setup is working
"""
# We can create an instance of an endpoint resource class, and use it to fetch details
access_token = self.get_token()
self.request.session['access_token'] = access_token
doctor_api = DoctorEndpoint(access_token)
patient_api = PatientEndpoint(access_token)
apppointment_api = AppointmentEndpoint(access_token)
# Grab the first doctor from the list; normally this would be the whole
# practice group, but your hackathon account probably only has one doctor in it.
doctor = doctor_api.get_and_store_data()
self.request.session['doctor'] = doctor.id
# Get patients and appointments for the doctor and store it in the local DB
patient_api.get_and_store_data(doctor=doctor)
date = datetime.now(
tz=pytz.timezone(doctor.timezone)).strftime('%Y-%m-%d')
apppointment_api.get_and_store_data(doctor=doctor, date=date)
return doctor
def get_patient_details_with_first_last_dob(self, fname, lname, dob):
api = PatientEndpoint(self.get_token())
for patients in api.list():
if patients['first_name'] == fname and patients[
'last_name'] == lname and str(
patients['date_of_birth']) == str(dob):
return patients['id']
def clean(self):
try:
oauth_provider = UserSocialAuth.objects.get(provider='drchrono')
access_token = oauth_provider.extra_data['access_token']
except UserSocialAuth.DoesNotExist:
raise forms.ValidationError(
"We had a problem authenticating with the drchrono API.")
full_name = f"{self.cleaned_data.get('first_name')} {self.cleaned_data.get('last_name')}"
appointments_client = AppointmentEndpoint(access_token)
patient_client = PatientEndpoint(access_token)
self.cleaned_data['appointment_id'] = None
self.cleaned_data['patient_id'] = None
# get a list of patients, make a list of their full names to search through
patients = list(patient_client.list())
patients_full_names = [
f"{patient.get('first_name')} {patient.get('last_name')}"
for patient in list(patient_client.list())
]
patient_found = full_name in patients_full_names
if not patient_found:
raise forms.ValidationError(
"Couldn't find a patient matching your name.")
patient = patients[patients_full_names.index(full_name)]
self.cleaned_data['patient_id'] = patient.get('id')
# okay, we found them. do they have an appt. ?
today = timezone.now()
today_str = today.strftime('%m-%d-%y')
appointments = list(
appointments_client.list(
{'patient': self.cleaned_data.get('patient_id')},
start=today_str,
end=today_str))
patient_has_appointment_today = len(appointments) > 0
if not patient_has_appointment_today:
raise forms.ValidationError(
"Couldn't find an appointment for you today.")
# if they have any appointments set their status to Arrived
for appointment in appointments:
self.cleaned_data['appointment_id'] = appointment.get('id')
import random
if random.randrange(20) % 4:
appointments_client.update(self.cleaned_data['appointment_id'],
{'status': 'Arrived'})
# create a Visit object
visit, created = Visit.objects.get_or_create(
appointment_id=self.cleaned_data['appointment_id'],
patient_id=self.cleaned_data['patient_id'])
# if there was already a Visit object and it is set to Arrived, they already checked in!
if not created and visit.status == 'Arrived':
raise forms.ValidationError(
"You already checked in for your appointment today.")
def get(self, request, patient_id):
# GET send a blank form for the patient
template = 'patient_details.html'
access_token = get_token()
patient_api = PatientEndpoint(access_token)
patient = patient_api.fetch(patient_id)
return render(request, template, {'patient': patient})
def get_patient(self, first_name=None, last_name=None, date_of_birth=None):
api = PatientEndpoint(self.access_token)
params = {'first_name': first_name, 'last_name': last_name, 'date_of_birth': date_of_birth}
# grab one
return next(api.list(params))
def get_patient_id(self, patient_id):
"""
:param patient_id:
:return:
"""
api = PatientEndpoint(self.access_token)
return api.fetch(patient_id)
def change_patient(self, id="None", data={}):
'''
Submit request to change an patient with ID
All request data is in dict 'data',
'''
access_token = self.get_token()
api = PatientEndpoint(access_token)
return api.update(id, data)
def post(self, request, appointment_id, patient_id):
form = self.patient_demographics(request.POST)
if form.is_valid():
try:
PatientEndpoint(access_token=get_token()).update(patient_id, form.cleaned_data)
updated_patient_dmg = PatientEndpoint(access_token=get_token()).fetch(patient_id)
patient_object, created = Patient.objects.update_or_create(
patient_id=updated_patient_dmg['id'],
defaults={
'gender': updated_patient_dmg['gender'],
'doctor_id': updated_patient_dmg['doctor'],
'first_name': updated_patient_dmg['first_name'],
'last_name': updated_patient_dmg['last_name'],
'email': updated_patient_dmg['email'],
'patient_photo': updated_patient_dmg['patient_photo']
}
)
appointment_details = AppointmentEndpoint(access_token=get_token()).fetch(appointment_id)
updated_appointment = {
'doctor': appointment_details['doctor'],
'duration': appointment_details['duration'],
'exam_room': appointment_details['exam_room'],
'office': appointment_details['office'],
'patient': appointment_details['patient'],
'scheduled_time': appointment_details['scheduled_time'],
'status': 'Arrived'
}
AppointmentEndpoint(access_token=get_token()).update(appointment_id,updated_appointment)
user_timezone = request.COOKIES.get('tzname_from_user')
time_now = datetime.now(pytz.timezone('UTC'))
arrival_time = time_now.astimezone(pytz.timezone(user_timezone))
appointment_object, created = Appointment.objects.update_or_create(
appointment_id=appointment_details['id'],
defaults={
'status': 'Arrived',
'patient': Patient.objects.get(patient_id=appointment_details['patient']),
'check_in_time': arrival_time,
'scheduled_time': appointment_details['scheduled_time']
}
)
return render(request, 'finish_check_in.html', {"patient": updated_patient_dmg})
except APIException:
form.add_error(None, 'Error in updating form. Please try again.')
return render(
request,
self.template_name,
{
'form': form,
'appointment_id': appointment_id,
'patient_id': patient_id,
})
def form_valid(self, form):
# This method is called when valid form data has been POSTed.
# It should return an HttpResponse.
date_of_birth = form.cleaned_data.get('date_of_birth')
gender = form.cleaned_data.get('gender')
address = form.cleaned_data.get('address')
zip_code = form.cleaned_data.get('zip_code')
city = form.cleaned_data.get('city')
state = form.cleaned_data.get('state')
email = form.cleaned_data.get('email')
cell_phone = form.cleaned_data.get('cell_phone')
emergency_contact_name = form.cleaned_data.get(
'emergency_contact_name')
emergency_contact_phone = form.cleaned_data.get(
'emergency_contact_phone')
patient_id = self.request.session.get('checkedin_patient')
patient = get_object_or_none(Patient, pk=patient_id)
if patient:
access_token = self.request.session.get('access_token')
patient_api = PatientEndpoint(access_token)
updated_fields = {
'email': email,
'gender': gender,
'date_of_birth': date_of_birth,
'address': address,
'city': city,
'state': state,
'zip_code': zip_code,
'cell_phone': cell_phone,
}
response = {}
try:
response = patient_api.update(patient_id, updated_fields)
updated_patient, created = update_or_create_object(
Patient, updated_fields, pk=patient_id)
return super(DemographicsView, self).form_valid(form)
except APIException:
context = {
'form':
form,
'message':
'Trouble updating your data, Please consult a staff member',
}
return render(self.request, "checkin.html", context)
context = {
'form':
form,
'message':
'Patient demographics not updated, please check with attendent',
}
return render(self.request, "checkin.html", context)
def getPatients(self):
access_token = self.get_token()
api = PatientEndpoint(access_token)
params = {}
params['doctor'] = 252849
# params['first_name'] = firstName
# params['last_name'] = lastName
return api.list(params=params)
def post_patientInfo(token, data, id):
"""
This is a helper function that once patient update their info, it can post update data to Patient API.
"""
patient_api = PatientEndpoint(token)
try:
response = patient_api.update(id, data)
except:
return HttpResponse('Please make sure your info is input correctly')
def form_valid(self, form):
patient_id = self.kwargs['p_id']
appointment_id = self.kwargs['a_id']
access_token = get_token()
api = PatientEndpoint(access_token)
ap_api = AppointmentEndpoint(access_token)
data = form.cleaned_data
api.update(id=patient_id, data=data)
ap_api.update(id=appointment_id, data={"status": "Arrived"})
return super(PatientInformationView, self).form_valid(form)
def get_patients(self):
"""
Get all patients (without pagenating)
Using ID as key
"""
access_token = self.get_token()
api = PatientEndpoint(access_token)
for patient in list(api.list()):
self.patients[patient['id']] = patient
return self.patients
def fetch_one_patient(self, id):
"""
Use the token we have stored in the DB to make an API request and get doctor details. If this succeeds, we've
proved that the OAuth setup is working
"""
# We can create an instance of an endpoint resource class, and use it to fetch details
access_token = self.get_token()
api = PatientEndpoint(access_token)
# Fetch one patient.
return api.fetch(id=id)
def get(self, request, *args, **kwargs):
'''
Return patient details
'''
patient = request.GET.get('patient')
doctor_welcome = DoctorWelcome()
access_token = doctor_welcome.get_token()
api = PatientEndpoint(access_token)
patient_data = api.fetch(patient)
return JsonResponse(patient_data)
def make_api_request(self):
"""
Use the token we have stored in the DB to make an API request and get doctor details. If this succeeds, we've
proved that the OAuth setup is working
"""
# We can create an instance of an endpoint resource class, and use it to fetch details
access_token = self.get_token()
api = PatientEndpoint(access_token)
# Grab the first doctor from the list; normally this would be the whole practice group, but your hackathon
# account probably only has one doctor in it.
return next(api.list())
def get_initial(self):
"""
Returns the initial data to use for forms on this view.
"""
initial = super(PatientInformationView, self).get_initial()
patient_id = self.kwargs['p_id']
access_token = get_token()
api = PatientEndpoint(access_token)
patient_info = api.fetch(id=patient_id)
initial = merge_two_dicts(patient_info, initial)
return initial
def debug(request):
oauth_provider = UserSocialAuth.objects.get(provider='drchrono')
access_token = oauth_provider.extra_data['access_token']
endpoint = PatientEndpoint(access_token)
print next(endpoint.list())
# queryset = Appointment.objects.all()
# serializer_class = retrieveAppointmentSerializer(queryset, many=True)
# content = serializer_class.data
# print content
return render(request, 'debug.html', {'data': next(endpoint.list())})
def post(self, request):
# create a form instance and populate it with data from the request:
form = DemographicForm(request.POST)
patient_id = request.POST.get('patient_id')
if form.is_valid():
oauth_provider = get_object_or_404(UserSocialAuth,
provider='drchrono')
access_token = oauth_provider.extra_data['access_token']
patient_client = PatientEndpoint(access_token)
patient_client.update(patient_id, form.cleaned_data)
return HttpResponseRedirect('/finished/')
return render(request, 'demographics.html', {'form': form})
def form_valid(self, form):
oauth_provider = UserSocialAuth.objects.get(provider='drchrono')
access_token = oauth_provider.extra_data['access_token']
endpoint = PatientEndpoint(access_token)
params = {}
for field in form.cleaned_data:
if form.cleaned_data[field] != "" and form.cleaned_data[field] != None:
params[field] = form.cleaned_data[field]
endpoint.update(self.kwargs['patient'], params)
return redirect('index')
def make_patient_api_request(access_token):
patient_api = PatientEndpoint(access_token)
for patient in patient_api.list():
Patient.objects.update_or_create(
pk=patient["id"],
defaults={
"doctor": Doctor.objects.get(id=patient["doctor"]),
"first_name": patient["first_name"],
"last_name": patient["last_name"],
"date_of_birth": patient["date_of_birth"],
"social_security_number": patient["social_security_number"],
"gender": patient["gender"]
})
def patient_db_save(self, token):
"""
Save patients info to patient table
"""
patient_api = PatientEndpoint(token)
for p in patient_api.list():
patient = models.Patient(patient_id=p[u'id'], first_name=p[u'first_name'], last_name=p[u'last_name'], \
date_of_birth=p[u'date_of_birth'], gender=p[u'gender'], address=p[u'address'], \
ssn=p[u'social_security_number'], cell_phone=p[u'cell_phone'], email=p[u'email'], \
city=p[u'city'], state=p[u'state'])
patient.save()
return
def createPatient(self):
"""
Use the token we have stored in the DB to make an API request and get doctor details. If this succeeds, we've
proved that the OAuth setup is working
"""
# We can create an instance of an endpoint resource class, and use it to fetch details
access_token = self.get_token()
api = PatientEndpoint(access_token)
params = {}
params['doctor'] = 252849
params['gender'] = 'Male'
params['first_name'] = 'Joe'
params['last_name'] = 'Blow'
return api.create(data=params)
def save(self, commit=True):
appointment = self.cleaned_data.pop('appointment')
appointment.checked_in_at = now()
appointment.save()
instance = super(PatientCheckinForm, self).save(commit=commit)
api = PatientEndpoint(instance.doctor.token)
data = {
'first_name': instance.first_name,
'last_name': instance.last_name,
'social_security_number': instance.social_security_number,
'race': instance.race,
'ethnicity': instance.ethnicity,
'date_of_birth': instance.date_of_birth,
}
api.update(instance.drchrono_id, data=data)
def get_context_data(self, **kwargs):
"""
:return: dictionary to populate template data
"""
print('PatientUpdateProfile get_context_data')
print('self = ', self)
print('self.kwargs[patient_id]=', self.kwargs['patient_id'])
kwargs = super(PatientUpdateProfile, self).get_context_data(**kwargs)
# get patient using patient_id
access_token = utility.get_token()
patient_api = PatientEndpoint(access_token)
patient = patient_api.fetch(id=str(self.kwargs['patient_id']))
patient = utility.convert_unicode_to_string(patient)
print('cellphone = ', patient['cell_phone'])
kwargs['patient'] = patient
return kwargs
def manage_patient(request):
if request.method == 'POST':
oauth_provider = UserSocialAuth.objects.get(provider='drchrono')
access_token = oauth_provider.extra_data['access_token']
api = PatientEndpoint(access_token)
for p in api.list():
patient = models.Patient(patient_id=p[u'id'], first_name=p[u'first_name'], last_name=p[u'last_name'], \
date_of_birth=p[u'date_of_birth'], gender=p[u'gender'], address=p[u'address'], \
ssn=p[u'social_security_number'], cell_phone=p[u'cell_phone'], email=p[u'email'], \
city=p[u'city'], state=p[u'state'], \
doctor_id=p[u'doctor'], last_app=p[u'date_of_first_appointment'], is_checkin=False)
patient.save()
else:
pass
patient_db = models.Patient.objects.all()
return render(request, 'patient_checkin.html', {})
