def view_CCD(request):
if request.method == "POST":
form = PatientForm(request.POST)
if form.is_valid():
json_chart = parse_ccda(
form.cleaned_data['patient'].chart.file.name)
request.session['CurrentPatient'] = json_chart
request.session['CurrentPatientXml'] = get_stylish_tables(
open(form.cleaned_data['patient'].chart.file.name).read())
xml_root = remove_namespaces(request.session['CurrentPatientXml'])
request.session['CurrentPatientTables'] = get_tables(xml_root)
suffix_tag = xml_root.find("recordTarget").find(
"patientRole").find("patient").find('name').find("suffix")
if suffix_tag:
request.session['middle'] = xml_root.find("recordTarget").find(
"patientRole").find("patient").find('name').find(
"suffix").text
elif 'middle' in request.session:
del request.session['middle']
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/patient_summary.html', {
'form': form,
'errors': errors
})
form = PatientForm()
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/patient_summary.html', {
'form': form,
'errors': errors
})
def patient_edit(request, orgStr, patientStr):
"""Edit an existing patient"""
patient = models.Patient.get_by_short_string(patientStr)
if not patient: raise Http404
def render_this(patient, patientForm):
return respond(request, 'patient_edit.html',
{'patient': patient, 'form': patientForm})
if request.method != 'POST':
patientForm = PatientForm(instance=patient)
return render_this(patient, patientForm)
patientForm = PatientForm(request.POST, instance=patient)
if not patientForm.is_valid():
# logging.info('patient_edit: %s' % patientForm.errors)
return render_this(patient, patientForm)
# store the patient
try:
patient = patientForm.save(commit=False)
# NOTE(dan): Use user's org, not possibly hacked org from the request.
patient.organization = request.user.organization
except ValueError, err:
patientForm.errors['__all__'] = unicode(err)
return render_this(patient, patientForm)
def add_patient(patient_id):
from forms import PatientForm
if patient_id:
id = int(patient_id.replace('P00', '').replace(
'P0', '').replace('P', ''))
patient = Patient.query.get(id)
else:
patient = Patient()
form = PatientForm(obj=patient)
if form.validate_on_submit():
if 'photo' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['photo']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = uuid.uuid4().hex+'.' + \
secure_filename(file.filename).split('.')[-1].lower()
form.photo.data.save(os.path.join(
app.config['UPLOAD_FOLDER'], 'patients', filename))
form.populate_obj(patient)
patient.photo = filename
patient.gender = Gender(form.gender.data)
db.session.add(patient)
db.session.commit()
url = url_for('patient_profile', patient_id=repr(patient))
flash(
'Patient saved with ID: {}, <a href="{}">view patient profile</a>'.format(repr(patient), url))
return redirect(url_for('add_patient'))
return render_template('add-patient.html', form=form)
def patient_self_checkin(request):
"""
Patient self check-in page
"""
if request.method == 'POST':
form = PatientForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
appointments = Appointment.objects.filter(patient_first_name=first_name,
patient_last_name=last_name).order_by('scheduled_time')
doctors = {}
# return only the pending appointments today, appointments overwritten here
appointments = [app for app in appointments if app.scheduled_time.date()
>= datetime.datetime.now().date()]
for a in appointments:
doctors[a.doctor_id] = a.get_doctor_name()
doctor_list = [doctors[a.doctor_id] for a in appointments]
reformatted_app_time = []
status_list = []
can_checkin = []
for a in appointments:
# e.g. 14:50:00
splited_time = str(a.scheduled_time).split()[-1].split('+')[0]
print "splited", splited_time
reformatted_app_time.append(splited_time)
# Todo consider to change the schema for appointment
access_token = Doctor.objects.get(user_id=a.doctor_id).access_token
status = Doctor.get_appointment_status(access_token, a.appointment_id)
status_list.append(status)
logger.info('status received as %s' % status)
not_check_in_status = ['Checked In', 'Arrived', 'In Room', 'Cancelled', 'In Session', 'No Show', 'Not Confirmed', 'Rescheduled', 'Complete']
if status in not_check_in_status:
can_checkin.append(False)
else:
can_checkin.append(True)
app_doctor_list = zip(appointments, doctor_list, reformatted_app_time, status_list, can_checkin)
context = {
'app_doctor': app_doctor_list,
'patient_first_name': first_name,
'patient_last_name': last_name,
}
print app_doctor_list
# print Doctor.get_patient_demograph('MY4CCJGbVW3Rq88fdQMzWmG23zIYah', 'Jenny', 'Harris')
return render(request, "patient_appointments.html", context)
else:
context = {
'form': form
}
return render(request, "patient_check_in.html", context)
else:
context = {'form': PatientForm}
return render(request, "patient_check_in.html", context)
def patch(self, request, **kwargs):
patient = get_object_or_404(Patient, pk=kwargs['pk'])
data = QueryDict(request.body)
form = PatientForm(data, instance=patient)
if form.is_valid():
form.save()
patientJSON = serializers.serialize("json", [patient])
return HttpResponse(patientJSON, content_type='application/json')
return HttpResponse(status=500)
def patient():
form = PatientForm()
req = request.form
if form.validate_on_submit():
session["Patient"] = req.get("Patient")
session["age"] = req.get("age")
session["Schuljahre"] = req.get("Schuljahre")
session["gender"] = req.get("gender")
return redirect(url_for('messwerte'))
return render_template('patient.html', title='Patientendaten Extern',
form=form)
def patient_create():
patient_form_create = PatientForm()
if patient_form_create.validate_on_submit():
form_data = patient_form_create.data
id = patient_form_create.patient_id.data
qry = db.patient_insert_sql(form_data)
db.insert(qry)
flash('New patient record created', 'success')
return redirect(f'/patient_created/{id}.html')
return render_template('patient_create.html',
template_form=patient_form_create)
def dashboard(request):
if request.method == "POST":
form = PatientForm(request.POST)
if form.is_valid():
json_chart = parse_ccda(form.cleaned_data['patient'].chart.file.name)
request.session['CurrentPatient'] = json_chart
request.session['CurrentPatientXml'] = open(form.cleaned_data['patient'].chart.file.name).read()
xml_root = remove_namespaces(request.session['CurrentPatientXml'])
request.session['CurrentPatientTables'] = get_tables(xml_root)
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/dashboard.html', {'form': form, 'errors': errors, })
form = PatientForm()
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/dashboard.html',{'form': form, 'errors': errors, })
def patientform(id,pid):
form=PatientForm()
reg = DoctorDetails.query.filter_by(id=id).first()
fees=0
visit=reg.home_visit_available
if request.method=="POST":
appoint = PatientDetails.query.filter_by(docid=id).all()
for a in appoint:
if a.pid==pid and a.status=="pending":
flash('you appointment is already under process')
return redirect(url_for('searchdoctor',pid=pid))
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
patient=PatientDetails(fullname=form.fullname.data,contact=form.contact.data,address=form.address.data,age=form.age.data,type=form.type.data,choice=form.choice.data,formfillingdate=now,appointmentdate=date.today(),appointmenttime=current_time,docid=id,pid=pid,status="pending",reason="none",gender=form.gender.data)
db.session.add(patient)
db.session.commit()
flash('you form is submitted successfully. Please check your notification for your appointment date and time!')
return redirect(url_for('home',id=pid))
return render_template('patientform.html',form=form,visit=visit,pid=pid)
def create(request, doctor_id=1):
if request.POST:
form = PatientForm(request.POST, request.FILES)
form.instance.Doctor_Visited_Id = doctor_id
if form.is_valid():
form.save()
args = {}
args['patients'] = Patient.objects.filter( Doctor_Visited_Id = doctor_id)
return render_to_response('patients.html', args)
else:
form = PatientForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['doctor'] = doctor_id
return render_to_response('create_patient.html', args)
def setup():
pform = PatientForm()
error = None
if pform.validate_on_submit():
#user input
name = pform.name.data
dob = pform.dob.data
street = pform.street_address.data
city = pform.city.data
state = pform.state.data
country = pform.country.data
telephone = pform.telephone.data
patient = models.add_patient(name, dob, street, city, state, country, telephone)
error = 'A patient with that patient id already exists'
return redirect('/patient')
return render_template('setup.html', error = error, form = pform)
def view_CCD(request):
if request.method == "POST":
form = PatientForm(request.POST)
if form.is_valid():
json_chart = parse_ccda(form.cleaned_data['patient'].chart.file.name)
request.session['CurrentPatient'] = json_chart
request.session['CurrentPatientXml'] = get_stylish_tables(open(form.cleaned_data['patient'].chart.file.name).read())
xml_root = remove_namespaces(request.session['CurrentPatientXml'])
request.session['CurrentPatientTables'] = get_tables(xml_root)
suffix_tag = xml_root.find("recordTarget").find("patientRole").find("patient").find('name').find("suffix")
if suffix_tag:
request.session['middle'] = xml_root.find("recordTarget").find("patientRole").find("patient").find('name').find("suffix").text
elif 'middle' in request.session:
del request.session['middle']
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/patient_summary.html', {'form': form, 'errors': errors})
form = PatientForm()
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/patient_summary.html', {'form': form, 'errors': errors})
def editPatientData(id):
# Initialize form from forms.py
form = PatientForm()
# if form is sent back (POST) to the server
if form.validate_on_submit():
# capture data from form
form_data = form.data
# build SQL query in update table
qry = db.patient_update_sql(form_data)
# update table with new data
try:
db.insert(qry)
except:
flash('Not able to update patient record', 'warning')
return render_template(f'edit-patient-data.html',
template_form=form,
id=id)
# redirect user to patient updated page
return redirect(f'/patient_updated/{id}.html')
# get values for this row from the database
sql = f"SELECT * FROM patient WHERE patient_id = '{id}'"
res = db.query(sql)
# populate values to the form
form.patient_id.data = res[0][0]
form.name.data = res[0][1]
form.address_street.data = res[0][2]
form.address_city.data = res[0][3]
form.address_state.data = res[0][4]
form.address_zip.data = res[0][5]
form.phone.data = res[0][6]
form.admitted.data = res[0][7]
form.discharged.data = res[0][8]
form.county_id.data = res[0][9]
form.health_info.data = res[0][10]
form.age.data = res[0][11]
form.race.data = res[0][12]
form.gender.data = res[0][13]
return render_template('edit-patient-data.html', template_form=form, id=id)
def insert_into_patient(request) :
if request.method == 'POST' :
form = PatientForm(request.POST)
if form.is_valid() :
c = connection.cursor()
ID = form.cleaned_data['ID']
name = form.cleaned_data['name']
age = form.cleaned_data['age']
sex = form.cleaned_data['sex']
BP = form.cleaned_data['BP']
height = form.cleaned_data['height']
weight = form.cleaned_data['weight']
address = form.cleaned_data['address']
contact = form.cleaned_data['contact']
condition = form.cleaned_data['condition']
admitted = form.cleaned_data['admitted']
fee = form.cleaned_data['fee']
c.execute("insert into patient VALUES(%s , %s , %s , %s , %s , %s , %s , %s , %s , %s , %s , %s)" , [ID , name , age , sex , BP, height, weight, address , contact , condition , admitted , fee])
c.close()
return HttpResponseRedirect("/mani_tables/show_patient")
def create(request, doctor_id=1):
if request.POST:
form = PatientForm(request.POST, request.FILES)
form.instance.Doctor_Visited_Id = doctor_id
if form.is_valid():
if User.objects.filter(username = request.POST['Patient_ID']).exists():
form.save()
return HttpResponseRedirect('/doctor/%s/all/' % doctor_id)
else:
print "Enter valid ID" # CHANGE THIS IN FUTURE FOR ERROR MESSAGE !
else:
form = PatientForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['doctor'] = doctor_id
return render_to_response('create_patient.html', args)
def edit_patient(patient_id):
pform = PatientForm()
#return redirect('/login')
error = None
patient_details = models.get_patient(patient_id)
if pform.validate_on_submit():
#user input
name = pform.name.data
dob = pform.dob.data
street = pform.street_address.data
city = pform.city.data
state = pform.state.data
country = pform.country.data
telephone = pform.telephone.data
models.update_patient(patient_id, name, dob, street, city, state, country, telephone)
return redirect('/patient')
return render_template('edit_patient.html', id=patient_id, form = pform, existing=patient_details)
def RegisterPatient(request):
if request.is_ajax() and request.method=='POST':
userForm=UserForm(request.POST)
pteForm=PatientForm(request.POST)
if userForm.is_valid() and pteForm.is_valid():
if DBRegisterPatient(request.user, userForm.cleaned_data, pteForm.cleaned_data.copy()):
from DDS.models import Hospital
hopsital = Hospital.objects.get(pk=1)
mensaje = request.POST.get('name',"")+" "+request.POST.get('apaterno',"")+" "+request.POST.get('amaterno',"")+", bienvenido a "+hopsital.razon+"\n\nUsuario: "+request.POST.get('username',"")+"\nContrasena: "+request.POST.get('password',"")
from django.core.mail import send_mail
send_mail(subject='Bienvenido a '+hopsital.razon, message=mensaje, from_email="*****@*****.**",
recipient_list=[userForm.cleaned_data['email']], fail_silently=False)
return HttpResponse("True")
return HttpResponse("Error interno")
else:
print pteForm.errors
else:
userForm = UserForm
pteForm = PatientForm
return RenderWithUser(request=request, template='Doctor/registrarPaciente.html',
dict={'uForm' : userForm, 'pForm' : pteForm}).getRendered()
def dashboard(request):
if request.method == "POST":
form = PatientForm(request.POST)
if form.is_valid():
json_chart = parse_ccda(
form.cleaned_data['patient'].chart.file.name)
request.session['CurrentPatient'] = json_chart
request.session['CurrentPatientXml'] = open(
form.cleaned_data['patient'].chart.file.name).read()
xml_root = remove_namespaces(request.session['CurrentPatientXml'])
request.session['CurrentPatientTables'] = get_tables(xml_root)
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/dashboard.html', {
'form': form,
'errors': errors,
})
form = PatientForm()
errors = form.errors or None # form not submitted or it has errors
return render(request, 'CCD/dashboard.html', {
'form': form,
'errors': errors,
})
def create(request, doctor_id=1):
if request.POST:
form = PatientForm(request.POST, request.FILES)
form.instance.Doctor_Visited_Id = doctor_id
if form.is_valid():
form.save()
args = {}
args['patients'] = Patient.objects.filter(
Doctor_Visited_Id=doctor_id)
return render_to_response('patients.html', args)
else:
form = PatientForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['doctor'] = doctor_id
return render_to_response('create_patient.html', args)
def render_forms (request) :
patient = PatientForm ()
department = DepartmentForm()
doctor = DoctorForm()
return render(request, 'mani_tables/all_forms.html', {'patient': patient , 'department' : department , 'doctor' : doctor})
def patient_new_with_visit(request, orgStr):
"""Add a new patient and a new visit to the new patient in one screen.
Note: You can add patients and visits without being logged in, but you will
only be able to see the last one.
"""
#logging.info("request.LANGUAGE_CODE: %s" % request.LANGUAGE_CODE)
#logging.info("request: %s" % request)
patient_exists = False
if not models.organization_exists(orgStr):
raise Http404
# NOTE(dan): patient doesn't change, so it need not be a param
def render_this(patient_exists, confirmationForm, patientForm, visitForm):
return respond(request, 'patient_new_with_visit.html',
{'patient_exists': patient_exists,
'confirmationform': confirmationForm,
'patientform': patientForm,
'visitform': visitForm,
'orgStr' : orgStr})
if request.method != 'POST':
confirmationForm = ConfirmationForm()
default_country = getattr(request.user, 'default_country', '')
if default_country:
patientForm = PatientForm(initial={'organization':orgStr, 'country': default_country})
else:
patientForm = PatientForm(initial={'organization':orgStr})
visitForm = VisitForm(initial={'organization':orgStr})
else:
confirmationForm = ConfirmationForm(request.POST)
patientForm = PatientForm(request.POST)
visitForm = VisitForm(request.POST)
if patientForm.is_valid() and visitForm.is_valid():
# First check if patient exists based on name and date of birth
name = patientForm.cleaned_data['name']
birth_date = patientForm.cleaned_data['birth_date']
patient = models.Patient.get_patient_by_name_birthdate(name, birth_date)
if patient:
patient_exists = True
request.session['patient'] = patient
# If patient is new
if not patient_exists:
# Need to store both
if not _store_new_patient_and_new_visit(request, orgStr, patientForm, visitForm):
return render_this(patient_exists, confirmationForm, patientForm, visitForm)
# We already went through this once and there is another patient with same name and birthdate
else:
if confirmationForm.is_valid():
confirmation_option = confirmationForm.cleaned_data['confirmation_option']
if confirmation_option == 'addpatientvisit':
# Need to store both
if not _store_new_patient_and_new_visit(request, orgStr, patientForm, visitForm):
return render_this(patient_exists, confirmationForm, patientForm, visitForm)
else:
# Patient is still the same
patient = request.session['patient']
# Just add the visit
newVisit = models.Visit(parent = patient)
visitForm = VisitForm(request.POST, instance = newVisit)
visit = _store_new_visit(patient, visitForm, request.user)
if not visit:
return render_this(patient_exists, confirmationForm, patientForm, visitForm)
else:
return render_this(patient_exists, confirmationForm, patientForm, visitForm)
patient = request.session['patient']
# Redirect to viewing
return HttpResponseRedirect(patient.get_view_url())
return render_this(patient_exists, confirmationForm, patientForm, visitForm)
def add(request):
""" Создание информации о пациенте """
avalible_error = False
error_texts = []
if request.method == "POST":
patient_form = PatientForm(request.POST)
if patient_form.is_valid():
patient = patient_form.save(commit=False)
else:
patient = None
avalible_error = True
visit_first_form = VisitFirstForm(request.POST,
prefix=VISIT_FIRST_PREFIX)
if not visit_first_form.is_valid():
avalible_error = True
visit_form = VisitForm(request.POST, prefix=VISIT_PREFIX)
if not visit_form.is_valid() and not avalible_error:
avalible_error = True
diagnosis_formset = DiagnosisFormset(request.POST,
prefix=DIAGNOSIS_PREFIX)
if not diagnosis_formset.is_valid():
avalible_error = True
avalible_data = [v for f in diagnosis_formset.forms for v in f.cleaned_data]
if len(avalible_data) < 1:
avalible_error = True
error_texts.append(u'Нужно записать хотя бы 1 диагноз')
if not avalible_error:
try:
p = patient
ps = Patient.objects.filter(last_name = p.last_name, first_name = p.first_name, patronymic = p.patronymic, birthday=p.birthday, type = p.type)
if len(ps) > 0:
raise
except:
e = u'Данный тип пациента с таким ФИО и датой рождения <a href="%s" target="_blank">уже есть в реестре</a>' % reverse('patient_edit', kwargs={'patient_id': ps[0].pk})
error_texts.append(e)
else:
visit_first = visit_first_form.save(commit=False)
visit_first.is_add = True
patient.date_registration = visit_first.date_created
patient.save()
save_formset(diagnosis_formset, patient)
visit_first.patient = patient
visit_first.save()
if visit_form.cleaned_data.get('is_visit', False):
visit = visit_form.save(commit=False)
#visit.mo = request.user.mo
visit.patient = patient
visit.save()
Patient.objects.filter(pk=patient.pk) \
.update(diagnosis_text = get_diagnosis_text(patient),
diagnosis_text_code = get_diagnosis_code(patient))
messages.add_message(request, messages.INFO, u'Пациент "%s" внесен в реестр' % patient.get_full_name())
redirect_to = request.POST.get('__redirect_to')
if redirect_to == 'edit':
url = reverse('patient_edit', kwargs={'patient_id': patient.pk})
elif redirect_to == 'add':
url = reverse('patient_add')
else:
url = reverse('patient_search')
return redirect(url)
else:
patient_form = PatientForm()
diagnosis_formset = DiagnosisFormset(prefix=DIAGNOSIS_PREFIX)
visit_form = VisitForm(prefix=VISIT_PREFIX, initial={'mo': request.user.mo.pk})
visit_first_form = VisitFirstForm(prefix=VISIT_FIRST_PREFIX,
initial={'mo': request.user.mo.pk})
response = {'patient_form': patient_form,
'diagnosis_formset': diagnosis_formset,
'visit_form': visit_form,
'visit_first_form': visit_first_form,
'error_texts': error_texts}
return render_to_response('patient_add.html',
response,
context_instance=RequestContext(request))
def edit(request, patient_id):
""" Просмотр и изменение информации о пациенте """
patient = get_object_or_404(Patient, pk=patient_id)
diagnosis_qs = patient.diagnosis_set.all()
avalible_error = False
try:
period_visit = datetime.now() - patient.visit_set.latest().date_created
except Visit.DoesNotExist:
period_visit = datetime.now() - datetime(1970, 1, 1)
is_need_save_visit = period_visit > timedelta(hours=12)
if request.method == "POST":
patient_form = PatientForm(request.POST,
instance=patient)
if patient_form.is_valid():
patient = patient_form.save(commit=False)
else:
avalible_error = True
visit_form = VisitForm(request.POST, prefix=VISIT_PREFIX)
if not visit_form.is_valid():
if period_visit > NIGHT_TIME:
avalible_error = True
else:
is_need_save_visit = False
visit_form = VisitForm(prefix=VISIT_PREFIX)
else:
is_need_save_visit = True
diagnosis_formset = DiagnosisModelFormset(clear_ids(request),
prefix=DIAGNOSIS_PREFIX,
queryset=diagnosis_qs)
if not diagnosis_formset.is_valid():
avalible_error = True
if not avalible_error:
save_formset(diagnosis_formset, patient)
patient.diagnosis_text = get_diagnosis_text(patient)
patient.diagnosis_text_code = get_diagnosis_code(patient)
patient.save()
messages.add_message(request,
messages.INFO,
u'Информация о пациенте изменена')
if visit_form.cleaned_data.get('is_visit', False):
visit = visit_form.save(commit=False)
#visit.mo = request.user.mo
visit.patient = patient
visit.save()
visit_form = VisitForm(prefix=VISIT_PREFIX,
initial={'mo': request.user.mo.pk})
# если все сохранилось, то правильно выводим где флажки "удалить", а где текст
diagnosis_formset = DiagnosisModelFormset(
prefix=DIAGNOSIS_PREFIX,
queryset=patient.diagnosis_set.all()
)
else:
patient_form = PatientForm(instance=patient)
diagnosis_formset = DiagnosisModelFormset(prefix=DIAGNOSIS_PREFIX,
queryset=diagnosis_qs)
visit_form = VisitForm(prefix=VISIT_PREFIX,
initial={'mo': request.user.mo.pk})
response = {'patient_form': patient_form,
'diagnosis_formset': diagnosis_formset,
'visit_form': visit_form,
'visits_qs': patient.visit_set.all(),
'patient': patient}
return render_to_response('patient_edit.html',
response,
context_instance=RequestContext(request))
def form():
form = PatientForm()
print("form generated")
if form.validate_on_submit():
print("form submitted and succeeded")
feature = Features(age=int(escape(form.age.data)),
apoe4=int(escape(form.apoe4.data)),
mmse=escape(form.mmse.data),
adas11=escape(form.adas11.data),
adas13=escape(form.adas13.data),
ICV=escape(form.ICV.data),
Ventricles=escape(form.Ventricles.data),
Entorhinal=escape(form.Entorhinal.data),
CEREBRUM=escape(form.CEREBRUM.data),
HIPPO=escape(form.HIPPO.data),
CSF=escape(form.CSF.data),
RAVLT_immediate=escape(form.RAVLT_immediate.data),
ABETA=escape(form.ABETA.data),
FAQTOTAL=escape(form.FAQTOTAL.data),
PTGENDER=escape(form.PTGENDER.data),
PTMARRY=escape(form.PTMARRY.data),
PTEDUCAT=escape(form.PTEDUCAT.data),
PTRACCAT=escape(form.PTRACCAT.data))
mrn = escape(form.medicalRecordNum.data)
# here we need to take the raw form values for imaging data and turn them into ratios in respect to ICV
# print("feature 2: ", featureList[2])
db.session.add(feature)
db.session.commit()
to_predict_list = [
int(escape(form.age.data)),
int(escape(form.apoe4.data)),
int(escape(form.mmse.data)),
int(escape(form.adas11.data)),
int(escape(form.adas13.data)),
int(escape(form.ICV.data)),
float(escape(form.Ventricles.data)),
float(escape(form.Entorhinal.data)),
float(escape(form.CEREBRUM.data)),
float(escape(form.HIPPO.data)),
float(escape(form.CSF.data)),
int(escape(form.RAVLT_immediate.data)),
int(escape(form.ABETA.data)),
int(escape(form.FAQTOTAL.data)),
int(escape(form.PTGENDER.data)),
int(escape(form.PTMARRY.data)),
int(escape(form.PTEDUCAT.data)),
int(escape(form.PTRACCAT.data))
]
print(to_predict_list)
sample = np.array(to_predict_list)
result = ModelClassification(to_predict_list)
proba = LIME(to_predict_list, sample)
print("Patient Data Submitted!")
flash('Patient data has been submitted!', 'success')
return redirect(url_for('result', result=result, mrn=mrn, proba=proba))
return render_template('form.html', title='Form', form=form)
def test_patient_form(self):
form = PatientForm(data={'model': ['Patient'], 'fields': ['dan']})
