def uploadResults(request):
currUser = request.user
currPerson = Person.objects.get(user=currUser)
currDoctor = Doctor.objects.get(personID=currPerson)
if request.method == 'POST':
form = TestUploadForm(request.POST, request.FILES)
if form.is_valid():
# resultFile = form.cleaned_data['results']
# patient = form.cleaned_data['patient']
# comments = form.cleaned_data['comments']
# testResults.objects.create(results=resultFile,doctor=currDoctor,
# patient=patient,comments=comments)
testResult = form.save(commit=False)
#testResults.objects.create(results=form.results,comments=form.comments)
testResult.doctor = currDoctor
testResult.save()
Logger.createLog('Created', currUser, testResult,
currDoctor.hospitalID)
return HttpResponseRedirect(reverse("results:viewTestResults"))
else:
print(form.errors)
else:
form = TestUploadForm()
context = {'doctor': currDoctor, 'form': form}
return render(request, 'testResults/uploadResults.html', context)
def compose(request, recipient=None, form_class=ComposeForm,
template_name='messaging/compose.html', success_url=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a person, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successful submission
"""
if request.method == "POST":
user_model = User.objects.get_by_natural_key(request.user.username)
sender = Person.objects.get(user=user_model)
form = form_class(request.POST, recipient_filter=None)
if form.is_valid():
form.save(sender=sender)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages:inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
Logger.createLog('Message',sender,form.recipient,None)
else:
form = form_class(recipient_filter=setRecipFilter(request))
if recipient is not None:
# recipients = [u for u in User.objects.filter(
# **{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipient
return render_to_response(template_name, {'form': form, }
, context_instance=RequestContext(request))
def uploadResults( request ):
currUser = request.user
currPerson = Person.objects.get(user=currUser)
currDoctor = Doctor.objects.get(personID=currPerson)
if request.method == 'POST':
form = TestUploadForm(request.POST,request.FILES)
if form.is_valid():
# resultFile = form.cleaned_data['results']
# patient = form.cleaned_data['patient']
# comments = form.cleaned_data['comments']
# testResults.objects.create(results=resultFile,doctor=currDoctor,
# patient=patient,comments=comments)
testResult = form.save(commit=False)
#testResults.objects.create(results=form.results,comments=form.comments)
testResult.doctor = currDoctor
testResult.save()
Logger.createLog('Created',currUser,testResult,currDoctor.hospitalID)
return HttpResponseRedirect(reverse("results:viewTestResults"))
else:
print(form.errors)
else:
form = TestUploadForm()
context = {'doctor':currDoctor,'form':form}
return render( request,'testResults/uploadResults.html',context )
def createHistory(request):
if request.method == 'POST':
medicalForm = MedicalHistoryForm(request.POST)
if medicalForm.is_valid():
med = medicalForm.save()
currentUser = request.user
user_model = User.objects.get_by_natural_key(currentUser.username)
person_model = Person.objects.get(user=user_model)
patient_model = Patient.objects.get(personID=person_model)
patient_model.medicalID = med
patient_model.save()
create = False
context = {'create': create, 'medical': med, 'medicalID': med.id}
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Created', logPerson, med, None)
return render(request, 'medicalHistory/index.html', context)
else:
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Standard error', logPerson, medicalForm.errors,
None)
print(medicalForm.errors)
else:
medicalForm = MedicalHistoryForm()
context = {'medicalForm': medicalForm}
return render(request, 'medicalHistory/create.html', context)
def createHistory(request):
if request.method == 'POST':
medicalForm = MedicalHistoryForm(request.POST)
if medicalForm.is_valid():
med = medicalForm.save()
currentUser = request.user
user_model = User.objects.get_by_natural_key(currentUser.username)
person_model = Person.objects.get(user=user_model)
patient_model = Patient.objects.get(personID=person_model)
patient_model.medicalID = med
patient_model.save()
create = False
context = {'create': create, 'medical': med,
'medicalID': med.id}
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Created',logPerson,med,None)
return render(request, 'medicalHistory/index.html', context)
else:
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Standard error',logPerson,medicalForm.errors,None)
print(medicalForm.errors)
else:
medicalForm = MedicalHistoryForm()
context = {'medicalForm': medicalForm}
return render(request, 'medicalHistory/create.html', context)
def updateAdmin(request, **kwargs):
"""
@function: updateProf
@description: Update the changes made a to user profile to the database.
"""
admID = kwargs.get('pk')
# Grab all of the model instances necessary
admin_model = Admin.objects.get(id=admID)
person_model = Person.objects.get(id=admin_model.personID.id)
user_model = User.objects.get_by_natural_key(person_model.user)
if request.method == 'POST':
# Create all necessary forms
userForm = UserForm(request.POST, instance=user_model)
personForm = PersonRegistrationForm(request.POST, instance=person_model)
employeeForm = updateAdminForm(request.POST, instance=admin_model)
# Validate forms
if (userForm.is_valid() and personForm.is_valid()
# and addressForm.is_valid()
):
# Save the user form.
userForm.save()
# Use the user updates to update the person object.
user_model = User.objects.get_by_natural_key(user_model.username)
birthday = personForm.cleaned_data['birthday']
phoneNumber = personForm.cleaned_data['phoneNumber']
Person.objects.filter(user=person_model.user).update(user=user_model,
birthday=birthday,
phoneNumber=phoneNumber)
admin_model.personID = person_model
admin_model.save()
logPerson = Person.objects.get(user=request.user)
Logger.createLog('Updated',logPerson,person_model,admin_model.hospitalID)
currentUser = User.objects.all().filter(id=request.user.id)
if currentUser == user_model:
return HttpResponseRedirect(reverse('profile:viewProfile'))
else:
return HttpResponseRedirect(reverse('profile:viewAllPersonnel'))
else:
print(userForm.errors, personForm.errors)
# Otherwise pre-fill all of the forms
else:
userForm = UserForm(instance=user_model)
personForm = PersonRegistrationForm(instance=person_model)
employeeForm = updateAdminForm(instance=admin_model)
context = {'user_form': userForm, 'personForm': personForm,
'admID': admin_model.id, 'user': user_model}
# Return all form information to the page
return render(request, 'userprofile/updateAdmin.html', context)
def update(request, **kwargs):
medID = kwargs.get('pk')
medical_model = get_object_or_404(MedicalHistory, pk=medID)
if request.method == 'POST':
medicalForm = MedicalHistoryForm(request.POST, instance=medical_model)
if medicalForm.is_valid():
patient_model = Patient.objects.get(medicalID=medID)
med = medicalForm.save()
patient_model.medicalID = med
patient_model.save()
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Updated',logPerson,med,None)
return redirect(reverse('medical:history', kwargs={'pk': medID}))
else:
Logger.createLog('Standard error',logPerson,medicalForm.errors,None)
print(medicalForm.errors)
else:
# Grab the char fields
histSystems = medical_model.histSystems
histSystemsOther = medical_model.histSystemsOther
histSurgeryOther = medical_model.histSurgeryOther
histAllergyOther = medical_model.histAllergyOther
histAllergyFoodOther = medical_model.histAllergyFoodOther
histMedicationOther = medical_model.histMedicationOther
histTobaccoOther = medical_model.histTobaccoOther
histTobaccoFrequency = medical_model.histTobaccoFrequency
histTobaccoDuration = medical_model.histTobaccoDuration
histAlcoholBeer = medical_model.histAlcoholBeer
histAlcoholShots = medical_model.histAlcoholShots
histDrugOther = medical_model.histDrugOther
histFamilyOther = medical_model.histFamilyOther
histWorkExplain = medical_model.histWorkExplain
histPrimaryName = medical_model.histPrimaryName
histPrimaryNumber = medical_model.histPrimaryNumber
medicalForm = MedicalHistoryForm(instance=medical_model)
charList = {'histPrimaryNumber': histPrimaryNumber, 'histPrimaryName': histPrimaryName,
'histSystems': histSystems, 'histSystemsOther': histSystemsOther,
'histAllergyOther': histAllergyOther, 'histAllergyFoodOther': histAllergyFoodOther,
'histSurgeryOther': histSurgeryOther, 'histMedicationOther': histMedicationOther,
'histTobaccoFrequency': histTobaccoFrequency, 'histTobaccoDuration': histTobaccoDuration,
'histAlcoholBeer': histAlcoholBeer, 'histAlcoholShots': histAlcoholShots,
'histTobaccoOther': histTobaccoOther, 'histDrugOther': histDrugOther,
'histFamilyOther': histFamilyOther, 'histWorkExplain': histWorkExplain, }
context = {'medicalForm': medicalForm, 'medicalID': medID, }
context.update(charList)
return render(request, 'medicalHistory/update.html', context)
def deleteHospital(request, **kwargs):
hospitalID = kwargs.get('pk')
hospitalModel = Hospital.objects.get(id=hospitalID)
if request.method == 'POST':
form = DeleteHospital(request.POST, instance=hospitalModel)
if form.is_valid():
logUser = User.objects.get_by_natural_key(request.user)
logPerson = Person.objects.get(user=logUser)
Logger.createLog('Removed',logPerson,str(Hospital.objects.get(id=hospitalID)),None)
Hospital.objects.get(id=hospitalID).delete()
# Only have to delete use because doing so deletes linked information
# Specifically: Address
return HttpResponseRedirect(reverse('hospital:view'))
else:
form = DeleteHospital(instance=hospitalModel)
context = {'form': form, 'hospitalID': hospitalID, 'hospital': hospitalModel}
return render(request, 'hospital/delete.html', context)
def createHospital(request):
"""
@function: createHospital
@description: This function handles a request for creating a hospital.
"""
# Boolean for successful schedule
creation_success = False
if request.method == 'POST':
hospitalForm = HospitalForm(request.POST)
addressForm = AddressForm(request.POST)
# Get the valid data from the form
if (hospitalForm.is_valid() and addressForm.is_valid()):
addr = addressForm.save()
addr.save()
hosp = hospitalForm.save()
hosp.address = addr
hosp.save()
logUser = User.objects.get_by_natural_key(request.user)
logPerson = Person.objects.get(user=logUser)
Logger.createLog('Created', logPerson, hosp, hosp)
Group.objects.create(name=str(hosp))
return HttpResponseRedirect(reverse('hospital:view'))
else:
pass
else:
hospitalForm = HospitalForm()
addressForm = AddressForm()
context = {
'hospitalForm': hospitalForm,
'addressForm': addressForm,
'creation_success': creation_success,
}
return render(request, 'hospital/create.html', context)
def logger(**kwargs):
'''
лог ошибок
event 1 (импорт из киноафиши):
code: 1 - нет города, 2 - нет кинотеатра, 3 - нет зала, 4 - нет фильма
event 2 (парсер sms.txt):
code: 1 - нет города, 2 - нет кинотеатра
event 3 (импорт сенсов из источников)
code: 1 - url не доступен, 2 - для источника нет сеансов, 3 - нет фильма
'''
url = None
text = None
extra = None
event = kwargs['event']
code = kwargs['code']
kinoafisha = 'http://www.kinoafisha.ru/index.php3'
if event == 1:
if code == 1:
text = 'Нет города (id на киноафише "%s")' % (kwargs['obj1'])
elif code == 2:
text = 'В городе "%s" нет кинотеатра' % (kwargs['obj1'])
url = '%s?id2=%s&status=2' % (kinoafisha, kwargs['obj2'])
elif code == 3:
url = '%s?id2=%s&status=2' % (kinoafisha, kwargs['obj2'])
text = 'В кинотеатре "%s" (г.%s) нет зала' % (kwargs['obj1'], kwargs['obj3'])
elif code == 4:
url = '%s?status=1&id1=%s' % (kinoafisha, kwargs['obj1'])
text = 'Нет фильма'
myfilter = {'{0}'.format('text'): text, '{0}'.format('url'): url, '{0}'.format('obj_name'): kwargs['bad_obj'], '{0}'.format('event'): event, '{0}'.format('code'): code,}
elif event == 2:
if code == 1:
text = 'Нет города'
url = kwargs['obj2']
elif code == 2:
text = 'В городе "%s" нет кинотеатра' % (kwargs['obj1'])
url = kwargs['obj2']
extra = kwargs['extra']
myfilter = {'{0}'.format('text'): text, '{0}'.format('url'): url, '{0}'.format('obj_name'): kwargs['bad_obj'], '{0}'.format('event'): event, '{0}'.format('code'): code,}
elif event == 3:
if code == 1:
url = kwargs['bad_obj']
text = 'Источник недоступен (id "%s")' % (kwargs['obj1'])
if code == 2:
url = kwargs['bad_obj']
text = 'Для источника (id "%s") нет сеансов' % (kwargs['obj1'])
if code == 3:
url = kwargs['obj1']
text = 'Нет фильма'
extra = kwargs['extra']
myfilter = {'{0}'.format('text'): text, '{0}'.format('obj_name'): kwargs['bad_obj'], '{0}'.format('event'): event, '{0}'.format('code'): code,}
try: Logger.objects.get(**myfilter)
except Logger.DoesNotExist: Logger(text=text, url=url, obj_name=kwargs['bad_obj'], extra=extra, event=event, code=code).save()
def createHospital(request):
"""
@function: createHospital
@description: This function handles a request for creating a hospital.
"""
# Boolean for successful schedule
creation_success = False
if request.method == 'POST':
hospitalForm = HospitalForm(request.POST)
addressForm = AddressForm(request.POST)
# Get the valid data from the form
if (hospitalForm.is_valid() and addressForm.is_valid()):
addr = addressForm.save()
addr.save()
hosp = hospitalForm.save()
hosp.address = addr
hosp.save()
logUser = User.objects.get_by_natural_key(request.user)
logPerson = Person.objects.get(user=logUser)
Logger.createLog('Created',logPerson,hosp,hosp)
Group.objects.create(name=str(hosp))
return HttpResponseRedirect(reverse('hospital:view'))
else:
pass
else:
hospitalForm = HospitalForm()
addressForm = AddressForm()
context = {'hospitalForm': hospitalForm,
'addressForm': addressForm,
'creation_success': creation_success,
}
return render(request, 'hospital/create.html', context)
def reply(request, message_id, form_class=ComposeForm,
template_name='messaging/compose.html', success_url=None,
recipient_filter=None, quote_helper=format_quote,
subject_template=_(u"Re: %(subject)s"), ):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote. To change the quote format
assign a different ``quote_helper`` kwarg in your url-conf.
"""
parent = get_object_or_404(Message, id=message_id)
user_model = User.objects.get_by_natural_key(request.user.username)
user = Person.objects.get(user=user_model)
if parent.sender != user and parent.recipient != user:
raise Http404
if request.method == "POST":
# The user sent the message
sender = user
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=sender, parent_msg=parent)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages:inbox')
Logger.createLog('Message',sender,form.recipient,None)
return HttpResponseRedirect(success_url)
else:
form = form_class(recipient_filter=setRecipFilter(request),
initial={
'body': '',
'subject': subject_template % {'subject': parent.subject},
'recipient': parent.sender
})
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def deleteHospital(request, **kwargs):
hospitalID = kwargs.get('pk')
hospitalModel = Hospital.objects.get(id=hospitalID)
if request.method == 'POST':
form = DeleteHospital(request.POST, instance=hospitalModel)
if form.is_valid():
logUser = User.objects.get_by_natural_key(request.user)
logPerson = Person.objects.get(user=logUser)
Logger.createLog('Removed', logPerson,
str(Hospital.objects.get(id=hospitalID)), None)
Hospital.objects.get(id=hospitalID).delete()
# Only have to delete use because doing so deletes linked information
# Specifically: Address
return HttpResponseRedirect(reverse('hospital:view'))
else:
form = DeleteHospital(instance=hospitalModel)
context = {
'form': form,
'hospitalID': hospitalID,
'hospital': hospitalModel
}
return render(request, 'hospital/delete.html', context)
def createPatient(request):
"""
@function: createPatient
@description:
- Registers a Patient
- Patient creates a User Account during Registration
- Patient inserts Address information via AddressForm
- Patient inserts Insurance information via InsuranceForm
- Patient inserts Emergency Contact via EmergencyContactForm
@param: request - a request made by a user
"""
# Set registered variable
registered = False
# If the request is a POST type
if request.method == 'POST':
# Create forms instance for users and patients
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
insuranceForm = InsuranceForm(request.POST)
addressForm = AddressForm(request.POST)
emergencyContForm = EmergencyContactForm(request.POST)
# Check if the form is valid
if (userForm.is_valid() and personForm.is_valid()) and (insuranceForm.is_valid() and addressForm.is_valid()) \
and (emergencyContForm.is_valid()):
# First save user form and set password
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Patient').user_set.add(user)
# Create a person
person = personForm.save(commit=False)
person.user = user
person.save()
# Save the address
address = addressForm.save(commit=False)
address.save()
# Save insurance info
insurance = insuranceForm.save(commit=False)
insurance.addressID = address
insurance.save()
# Save emergency contact info
emergencyForm = emergencyContForm.save(commit=False)
forms = getFormTuple(person, address, insurance)
objects = getObjectTuple(EmergencyContact, emergencyForm, Person, Patient)
checkContact(forms, objects)
# Set registered variable
registered = True
registerAttempt = True
Logger.createLog("Registered", person)
else:
registerAttempt = True
print(userForm.errors, personForm.errors, insuranceForm.errors, addressForm.errors,
emergencyContForm.errors)
# If the request is not of POST type
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
insuranceForm = InsuranceForm()
addressForm = AddressForm()
emergencyContForm = EmergencyContactForm()
registerAttempt = True
context = {'user_form': userForm, 'patientRegistration': personForm,
'addressForm': addressForm, 'insuranceForm': insuranceForm,
'emergencyForm': emergencyContForm, 'registered': registered,
'registerAttempt': registerAttempt}
return render(request, 'register/createPatient.html', context)
def createAdmin(request):
if request.user.groups.filter(name='Root').exists():
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
addressForm = AddressForm(request.POST)
adminForm = AdminRootForm(request.POST)
if (userForm.is_valid() and personForm.is_valid()
and addressForm.is_valid() and adminForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Admin').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
adm = adminForm.save(commit=False)
adm.personID = person
adm.addressID = address
adm.save()
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(
request.user.username))
Logger.createLog('Created', logPerson, adm.personID,
adm.hospitalID)
return HttpResponseRedirect(reverse('profile:userLogin'))
else:
print(userForm.errors, personForm.errors, addressForm.errors,
adminForm.errors)
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
adminForm = AdminRootForm()
return render(
request, 'register/createAdmin.html', {
'user_form': userForm,
'adminRegistration': personForm,
'addressForm': addressForm,
'adminForm': adminForm
})
# If the registering user is an admin for a hospital
else:
adminModel = get_object_or_404(
Admin,
personID=Person.objects.get(
user=User.objects.get_by_natural_key(request.user)))
hospitalID = adminModel.hospitalID
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
addressForm = AddressForm(request.POST)
adminForm = AdminForm(request.POST)
if (userForm.is_valid() and personForm.is_valid()
and addressForm.is_valid() and adminForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Admin').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
adm = adminForm.save(commit=False)
adm.personID = person
adm.hospitalID = hospitalID
adm.addressID = address
adm.save()
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(
request.user.username))
Logger.createLog('Created', logPerson, adm.personID,
adm.hospitalID)
return HttpResponseRedirect(reverse('profile:userLogin'))
else:
print(userForm.errors, personForm.errors, addressForm.errors,
adminForm.errors)
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
adminForm = AdminForm()
return render(
request, 'register/createAdmin.html', {
'user_form': userForm,
'adminRegistration': personForm,
'addressForm': addressForm,
'adminForm': adminForm
})
def createPatient(request):
"""
@function: createPatient
@description:
- Registers a Patient
- Patient creates a User Account during Registration
- Patient inserts Address information via AddressForm
- Patient inserts Insurance information via InsuranceForm
- Patient inserts Emergency Contact via EmergencyContactForm
@param: request - a request made by a user
"""
# Set registered variable
registered = False
# If the request is a POST type
if request.method == 'POST':
# Create forms instance for users and patients
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
insuranceForm = InsuranceForm(request.POST)
addressForm = AddressForm(request.POST)
emergencyContForm = EmergencyContactForm(request.POST)
# Check if the form is valid
if (userForm.is_valid() and personForm.is_valid()) and (insuranceForm.is_valid() and addressForm.is_valid()) \
and (emergencyContForm.is_valid()):
# First save user form and set password
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Patient').user_set.add(user)
# Create a person
person = personForm.save(commit=False)
person.user = user
person.save()
# Save the address
address = addressForm.save(commit=False)
address.save()
# Save insurance info
insurance = insuranceForm.save(commit=False)
insurance.addressID = address
insurance.save()
# Save emergency contact info
emergencyForm = emergencyContForm.save(commit=False)
forms = getFormTuple(person, address, insurance)
objects = getObjectTuple(EmergencyContact, emergencyForm, Person,
Patient)
checkContact(forms, objects)
# Set registered variable
registered = True
registerAttempt = True
Logger.createLog("Registered", person)
else:
registerAttempt = True
print(userForm.errors, personForm.errors, insuranceForm.errors,
addressForm.errors, emergencyContForm.errors)
# If the request is not of POST type
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
insuranceForm = InsuranceForm()
addressForm = AddressForm()
emergencyContForm = EmergencyContactForm()
registerAttempt = True
context = {
'user_form': userForm,
'patientRegistration': personForm,
'addressForm': addressForm,
'insuranceForm': insuranceForm,
'emergencyForm': emergencyContForm,
'registered': registered,
'registerAttempt': registerAttempt
}
return render(request, 'register/createPatient.html', context)
def createNurse(request, **kwargs):
if request.user.groups.filter(name='Root').exists():
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
addressForm = AddressForm(request.POST)
nurseForm = NurseRootForm(request.POST)
if (userForm.is_valid() and personForm.is_valid()
and addressForm.is_valid() and nurseForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Nurse').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
nurse = nurseForm.save(commit=False)
nurse.personID = person
nurse.addressID = address
nurse.save()
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(
request.user.username))
Logger.createLog('Created', logPerson, nurse.personID,
nurse.hospitalID)
return HttpResponseRedirect(reverse('profile:userLogin'))
else:
pass
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
nurseForm = NurseRootForm()
return render(
request, 'register/createNurse.html', {
'user_form': userForm,
'nurseRegistration': personForm,
'addressForm': addressForm,
'nurseForm': nurseForm
})
# If the registering user is an admin for a hospital
else:
adminModel = get_object_or_404(
Admin,
personID=Person.objects.get(
user=User.objects.get_by_natural_key(request.user)))
hospitalID = adminModel.hospitalID
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
nurseForm = NurseForm(request.POST)
addressForm = AddressForm(request.POST)
if (userForm.is_valid() and personForm.is_valid()
and addressForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Nurse').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
nurse = nurseForm.save(commit=False)
nurse.personID = person
nurse.hospitalID = hospitalID
nurse.addressID = address
nurse.save()
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(
request.user.username))
Logger.objects.create(type='Created',
user1=logPerson,
user2=nurse.personID)
Logger.createLog('Created', logPerson, nurse.personID,
nurse.hospitalID)
return HttpResponseRedirect(reverse('base:landing'))
else:
pass
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
nurseForm = NurseForm()
return render(
request, 'register/createNurse.html', {
'user_form': userForm,
'nurseRegistration': personForm,
'addressForm': addressForm,
'nurseForm': nurseForm
})
def update(request, **kwargs):
medID = kwargs.get('pk')
medical_model = get_object_or_404(MedicalHistory, pk=medID)
if request.method == 'POST':
medicalForm = MedicalHistoryForm(request.POST, instance=medical_model)
if medicalForm.is_valid():
patient_model = Patient.objects.get(medicalID=medID)
med = medicalForm.save()
patient_model.medicalID = med
patient_model.save()
logPerson = Person.objects.get(
user=User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Updated', logPerson, med, None)
return redirect(reverse('medical:history', kwargs={'pk': medID}))
else:
Logger.createLog('Standard error', logPerson, medicalForm.errors,
None)
print(medicalForm.errors)
else:
# Grab the char fields
histSystems = medical_model.histSystems
histSystemsOther = medical_model.histSystemsOther
histSurgeryOther = medical_model.histSurgeryOther
histAllergyOther = medical_model.histAllergyOther
histAllergyFoodOther = medical_model.histAllergyFoodOther
histMedicationOther = medical_model.histMedicationOther
histTobaccoOther = medical_model.histTobaccoOther
histTobaccoFrequency = medical_model.histTobaccoFrequency
histTobaccoDuration = medical_model.histTobaccoDuration
histAlcoholBeer = medical_model.histAlcoholBeer
histAlcoholShots = medical_model.histAlcoholShots
histDrugOther = medical_model.histDrugOther
histFamilyOther = medical_model.histFamilyOther
histWorkExplain = medical_model.histWorkExplain
histPrimaryName = medical_model.histPrimaryName
histPrimaryNumber = medical_model.histPrimaryNumber
medicalForm = MedicalHistoryForm(instance=medical_model)
charList = {
'histPrimaryNumber': histPrimaryNumber,
'histPrimaryName': histPrimaryName,
'histSystems': histSystems,
'histSystemsOther': histSystemsOther,
'histAllergyOther': histAllergyOther,
'histAllergyFoodOther': histAllergyFoodOther,
'histSurgeryOther': histSurgeryOther,
'histMedicationOther': histMedicationOther,
'histTobaccoFrequency': histTobaccoFrequency,
'histTobaccoDuration': histTobaccoDuration,
'histAlcoholBeer': histAlcoholBeer,
'histAlcoholShots': histAlcoholShots,
'histTobaccoOther': histTobaccoOther,
'histDrugOther': histDrugOther,
'histFamilyOther': histFamilyOther,
'histWorkExplain': histWorkExplain,
}
context = {
'medicalForm': medicalForm,
'medicalID': medID,
}
context.update(charList)
return render(request, 'medicalHistory/update.html', context)
def updateProf(request, **kwargs):
"""
@function: updateProf
@description: Update the changes made a to user profile to the database.
"""
# Current user
current_user = request.user
# Grab all of the model instances necessary
user_model = User.objects.get_by_natural_key(current_user.username)
person_model = Person.objects.get(user=user_model)
patient_model = Patient.objects.get(personID=person_model.id)
insurance_model = Insurance.objects.get(id=patient_model.insuranceID.id)
address_model = Address.objects.get(id=patient_model.addressID.id)
emergency_model = Cemergencycontact.objects.get(id=patient_model.emergencyContactID.id)
if request.method == 'POST':
# Create all necessary forms
userForm = UserForm(request.POST, instance=current_user)
personForm = PersonRegistrationForm(request.POST, instance=person_model)
insuranceForm = InsuranceForm(request.POST, instance=insurance_model)
addressForm = AddressForm(request.POST, instance=address_model)
emergencyContForm = EmergencyContactForm(request.POST, emergency_model)
# Validate forms
if (userForm.is_valid() and personForm.is_valid()) and insuranceForm.is_valid() \
and (addressForm.is_valid() and emergencyContForm.is_valid()):
# Save the user form.
userForm.save()
birthday = personForm.cleaned_data['birthday']
phoneNumber = personForm.cleaned_data['phoneNumber']
# use the user updates to update the person object.
user_model = User.objects.get(username=current_user.username)
Cperson.objects.filter(user=current_user).update(user=user_model,
birthday=birthday,
phoneNumber=phoneNumber)
insuranceName = insuranceForm.cleaned_data['name']
policyNumber = insuranceForm.cleaned_data['policyNumber']
# update all insurance, address, and emergency contact
# information if necessary.
insurance_model.name = insuranceName
insurance_model.policyNumber = policyNumber
insurance_model.personID = person_model
insurance_model.save()
street = addressForm.cleaned_data['street']
zipCode = addressForm.cleaned_data['zip']
city = addressForm.cleaned_data['city']
state = addressForm.cleaned_data['state']
address_model.street = street
address_model.zip = zipCode
address_model.city = city
address_model.state = state
address_model.save()
emerFirstName = emergencyContForm.cleaned_data['firstName']
emerLastName = emergencyContForm.cleaned_data['lastName']
emergencyNumber = emergencyContForm.cleaned_data['emergencyNumber']
emergency_model.firstName = emerFirstName
emergency_model.lastName = emerLastName
emergency_model.emergencyNumber = emergencyNumber
emergency_model.save()
# send all updates to the patient
patient_model.addressID = address_model
patient_model.insuranceID = insurance_model
patient_model.personID = person_model
patient_model.emergencyContactID = emergency_model
patient_model.save()
logPerson = Person.objects.get(
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Updated',logPerson,patient_model.personID,None)
return HttpResponseRedirect(reverse('profile:viewProfile'))
else:
print(userForm.errors, personForm.errors, emergencyContForm.errors, addressForm.errors,
insuranceForm.errors)
# Otherwise pre-fill all of the forms
else:
userForm = UserForm(instance=current_user)
personForm = PersonRegistrationForm(instance=person_model)
insuranceForm = InsuranceForm(instance=insurance_model)
addressForm = AddressForm(instance=address_model)
emergencyContForm = EmergencyContactForm(instance=emergency_model)
context = {'user_form': userForm, 'patientRegistration': personForm,
'addressForm': addressForm, 'insuranceForm': insuranceForm,
'emergencyForm': emergencyContForm, 'patientID': patient_model.id}
# Return all form information to the page
return render(request, 'userprofile/updateProfile.html', context)
def createNurse(request, **kwargs):
if request.user.groups.filter(name='Root').exists():
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
addressForm = AddressForm(request.POST)
nurseForm = NurseRootForm(request.POST)
if (userForm.is_valid() and personForm.is_valid() and addressForm.is_valid() and nurseForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Nurse').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
nurse = nurseForm.save(commit=False)
nurse.personID = person
nurse.addressID = address
nurse.save()
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Created', logPerson, nurse.personID, nurse.hospitalID)
return HttpResponseRedirect(reverse('profile:userLogin'))
else:
pass
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
nurseForm = NurseRootForm()
return render(request, 'register/createNurse.html',
{'user_form': userForm, 'nurseRegistration': personForm,
'addressForm': addressForm, 'nurseForm': nurseForm})
# If the registering user is an admin for a hospital
else:
adminModel = get_object_or_404(Admin, personID=Person.objects
.get(user=User.objects
.get_by_natural_key(request.user)))
hospitalID = adminModel.hospitalID
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
nurseForm = NurseForm(request.POST)
addressForm = AddressForm(request.POST)
if (userForm.is_valid() and personForm.is_valid() and addressForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Nurse').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
nurse = nurseForm.save(commit=False)
nurse.personID = person
nurse.hospitalID = hospitalID
nurse.addressID = address
nurse.save()
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.objects.create(type='Created', user1=logPerson, user2=nurse.personID)
Logger.createLog('Created', logPerson, nurse.personID, nurse.hospitalID)
return HttpResponseRedirect(reverse('base:landing'))
else:
pass
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
nurseForm = NurseForm()
return render(request, 'register/createNurse.html',
{'user_form': userForm, 'nurseRegistration': personForm,
'addressForm': addressForm, 'nurseForm': nurseForm})
def createAdmin(request):
if request.user.groups.filter(name='Root').exists():
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
addressForm = AddressForm(request.POST)
adminForm = AdminRootForm(request.POST)
if (userForm.is_valid() and personForm.is_valid() and addressForm.is_valid() and adminForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Admin').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
adm = adminForm.save(commit=False)
adm.personID = person
adm.addressID = address
adm.save()
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Created', logPerson, adm.personID, adm.hospitalID)
return HttpResponseRedirect(reverse('profile:userLogin'))
else:
print(userForm.errors, personForm.errors, addressForm.errors, adminForm.errors)
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
adminForm = AdminRootForm()
return render(request, 'register/createAdmin.html',
{'user_form': userForm, 'adminRegistration': personForm,
'addressForm': addressForm, 'adminForm': adminForm})
# If the registering user is an admin for a hospital
else:
adminModel = get_object_or_404(Admin, personID=Person.objects
.get(user=User.objects
.get_by_natural_key(request.user)))
hospitalID = adminModel.hospitalID
if request.method == 'POST':
userForm = UserForm(request.POST)
personForm = PersonRegistrationForm(request.POST)
addressForm = AddressForm(request.POST)
adminForm = AdminForm(request.POST)
if (userForm.is_valid() and personForm.is_valid() and addressForm.is_valid() and adminForm.is_valid()):
user = userForm.save()
user.set_password(user.password)
user.save()
Group.objects.get(name='Admin').user_set.add(user)
person = personForm.save(commit=False)
person.user = user
person.save()
address = addressForm.save(commit=False)
address.save()
adm = adminForm.save(commit=False)
adm.personID = person
adm.hospitalID = hospitalID
adm.addressID = address
adm.save()
logPerson = Person.objects.get(user=
User.objects.get_by_natural_key(request.user.username))
Logger.createLog('Created', logPerson, adm.personID, adm.hospitalID)
return HttpResponseRedirect(reverse('profile:userLogin'))
else:
print(userForm.errors, personForm.errors, addressForm.errors, adminForm.errors)
else:
userForm = UserForm()
personForm = PersonRegistrationForm()
addressForm = AddressForm()
adminForm = AdminForm()
return render(request, 'register/createAdmin.html',
{'user_form': userForm, 'adminRegistration': personForm,
'addressForm': addressForm, 'adminForm': adminForm})