def login_view(request):
# Authentication check. Users currently logged in cannot view this page.
if request.user.is_authenticated:
return HttpResponseRedirect('/profile/')
elif Account.objects.all().count() == 0:
return HttpResponseRedirect('/setup/')
# get template data from session
template_data = views.parse_session(request, {'form_button': "Login"})
# Proceed with the rest of view
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['email'].lower(),
password=form.cleaned_data['password'])
userInfo = Account.objects.get(user=user)
if userInfo.archive == False:
login(request, user)
logger.log(Action.ACTION_ACCOUNT, "Account login",
request.user.account)
request.session[
'alert_success'] = "Successfully logged into VirtualClinic."
return HttpResponseRedirect('/profile/')
else:
request.session[
'alert_danger'] = "Account is archived! Please create a new account"
return HttpResponseRedirect('/register/')
else:
form = LoginForm()
template_data['form'] = form
return render(request, 'virtualclinic/login.html', template_data)
def parse_appointment_cancel(request, template_data):
if request.method == 'POST':
if 'cancel' in request.POST and 'pk' in request.POST:
pk = request.POST['pk']
try:
appointment = Appointment.objects.get(pk=pk)
except Exception:
template_data[
'alert_danger'] = "Unable to cancel the appointment. Please try again later."
return
if request.user.account.role == Account.ACCOUNT_PATIENT and request.user.account != appointment.patient:
template_data[
'alert_danger'] = "You don't have permission to cancel that appointment."
return
elif request.user.account.role == Account.ACCOUNT_DOCTOR and request.user.account != appointment.doctor:
template_data[
'alert_danger'] = "You don't have permission to cancel that appointment."
return
elif appointment.status == "Cancelled":
template_data[
'alert_danger'] = "That appointment was already cancelled."
return
appointment.status = "Cancelled"
appointment.save()
logger.log(Action.ACTION_APPOINTMENT, 'Appointment cancelled',
request.user.account)
if request.user.account.role == Account.ACCOUNT_DOCTOR:
message.send_appointment_cancel(request, appointment,
appointment.patient)
if request.user.account.role == Account.ACCOUNT_PATIENT:
message.send_appointment_cancel(request, appointment,
appointment.doctor)
template_data[
'alert_success'] = "The appointment has been cancelled."
def add_symptom(request):
# Authentication check
authentication_result = views.authentication_check(request,
[Account.ACCOUNT_ADMIN])
if authentication_result is not None:
return authentication_result
# Get template data from the session
template_data = views.parse_session(request,
{'form_button': "Add Symptom"})
#parse_speciality_delete(request, template_data) # parse appointment cancelling
# Proceed with the rest of the view
if request.method == 'POST':
form = SymptomForm(request.POST)
if form.is_valid():
symptom = Symptom(name=form.cleaned_data['name'],
description=form.cleaned_data['description'])
symptom.save()
form = SymptomForm() # Clean the form when page is redisplayed
template_data['alert_success'] = "Successfully added the Symptom!"
logger.log(Action.ACTION_ADMIN, 'Admin added ' + symptom.name,
request.user.account)
return HttpResponseRedirect('/admin/symptom')
else:
form = SymptomForm()
template_data['form'] = form
return render(request, 'virtualclinic/admin/add_symptom.html',
template_data)
def new_view(request):
# Authentication Check
authentication_result = views.authentication_check(request)
if authentication_result is not None:
return authentication_result
# Get template data from session
template_data = views.parse_session(request,
{'form_button': "Send Message"})
# Proceed with the rest of the view
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
message = form.generate(request.user.account)
message.save()
logger.log(Action.ACTION_MESSAGE, 'Message Sent',
request.user.account)
request.session[
'alert_success'] = "Successfully sent your message!"
return HttpResponseRedirect('/message/list')
else:
# Validation Check. Make sure a message exists for the given pk.
default = {}
if 'pk' in request.GET:
pk = request.GET['pk']
try:
account = Account.objects.get(pk=pk)
default['target'] = pk
except Exception:
template_data[
'alert_danger'] = "We couldn't find your the person you're replying to. Please try again"
form = MessageForm(default)
form.clear_errors()
template_data['form'] = form
return render(request, 'virtualclinic/message/new.html', template_data)
def createemployee_view(request):
# Authentication check.
authentication_result = views.authentication_check(request,
[Account.ACCOUNT_ADMIN])
if authentication_result is not None: return authentication_result
# Get the template data from the session
template_data = views.parse_session(request, {'form_button': "Register"})
# Proceed with the rest of the view
if request.method == 'POST':
form = EmployeeRegistrationForm(request.POST)
if form.is_valid():
user = views.register_user(form.cleaned_data['email'],
form.cleaned_data['password_first'],
form.cleaned_data['firstname'],
form.cleaned_data['lastname'],
form.cleaned_data['employee'],
form.cleaned_data['speciality'])
logger.log(Action.ACTION_ADMIN,
'Admin registered ' + user.username,
request.user.account)
request.session[
'alert_success'] = "Successfully created new employee account"
return HttpResponseRedirect('/admin/users/')
else:
form = EmployeeRegistrationForm()
template_data['form'] = form
return render(request, 'virtualclinic/admin/createemployee.html',
template_data)
def setup_view(request):
if Account.objects.all().count() > 0:
request.session['alert_success'] = "Setup has already been completed."
return HttpResponseRedirect('/')
# Get template data from the session
template_data = views.parse_session(request, {'form_button': "Register"})
# Proceed with rest of the view
if request.method == 'POST':
form = AccountRegisterForm(request.POST)
if form.is_valid():
views.register_user(form.cleaned_data['email'],
form.cleaned_data['password_first'],
form.cleaned_data['firstname'],
form.cleaned_data['lastname'],
Account.ACCOUNT_ADMIN)
user = authenticate(
username=form.cleaned_data['email'].lower(
), # Make sure it's lowercase
password=form.cleaned_data['password_first'])
logger.log(Action.ACTION_ACCOUNT, "Account login", user.account)
login(request, user)
request.session[
'alert_success'] = "Successfully setup Virtual Clinic's primary admin account."
return HttpResponseRedirect('/profile/')
else:
form = AccountRegisterForm()
template_data['form'] = form
return render(request, 'virtualclinic/setup.html', template_data)
def parse_message_archive(request, template_data):
if request.method == 'POST':
if 'delete' in request.POST and 'pk' in request.POST:
pk = request.POST['pk']
try:
message = Message.objects.get(pk=pk)
except Exception:
template_data[
'alert_danger'] = "Unable to archive the message. Please try again later."
return
if message.sender == request.user.account:
if message.sender_deleted:
template_data[
'alert_danger'] = "That message was already archived."
return
message.sender_deleted = True
if message.target == request.user.account:
if message.target_deleted:
template_data[
'alert_danger'] = "That message was already archived."
return
message.target_deleted = True
message.save()
logger.log(Action.ACTION_MESSAGE, 'Message Archived',
request.user.account)
template_data['alert_success'] = "The message was archived."
def create_view(request):
# Authentication check
authentication_result = views.authentication_check(
request,
[Account.ACCOUNT_DOCTOR, Account.ACCOUNT_LAB]
)
if authentication_result is not None:
return authentication_result
# get template data from session
template_data = views.parse_session(request, {'form_button': "Upload"})
# proceed with rest of the view
default = {}
if request.user.account.role == Account.ACCOUNT_DOCTOR:
default['doctor'] = request.user.account.pk
if 'hospital' not in request.POST and request.user.account.profile.prefHospital is not None:
default['hospital'] = request.user.account.profile.prefHospital.pk
if 'date' not in request.POST:
default['date'] = datetime.now().strftime("%Y-%m-%d")
request.POST._mutable = True
request.POST.update(default)
form = MedTestForm(request.POST,request.FILES)
if request.method == 'POST':
if form.is_valid():
medicaltest = form.generate()
medicaltest.save()
logger.log(Action.ACTION_MEDTEST,'Medical Test Created', request.user.account)
form = MedTestForm(default) # clean form data
#form.disable_field('doctor')
form._errors = {}
template_data['alert_success'] = "Successfully uploaded medical test"
else:
form._errors = {}
#form.disable_field('doctor')
template_data['form'] = form
return render(request,'virtualclinic/medtest/upload.html', template_data)
def register_view(request):
# Authentication check. Users logged in cannot view this page.
if request.user.is_authenticated:
return HttpResponseRedirect('/profile/')
elif Account.objects.all().count() == 0:
return HttpResponseRedirect('/setup/')
# Get template data from session
template_data = views.parse_session(request, {'form_button': "Register"})
# Proceed with rest of the view
if request.method == 'POST':
form = AccountRegisterForm(request.POST)
if form.is_valid():
views.register_user(
form.cleaned_data['email'],
form.cleaned_data['password_first'],
form.cleaned_data['firstname'],
form.cleaned_data['lastname'],
# form.cleaned_data['speciality'],
Account.ACCOUNT_PATIENT)
user = authenticate(username=form.cleaned_data['email'].lower(),
password=form.cleaned_data['password_first'])
logger.log(Action.ACTION_ACCOUNT, "Account Login", user.account)
login(request, user)
request.session[
'alert_success'] = "Successfully registered with VirtualClinic."
return HttpResponseRedirect('/profile/')
else:
form = AccountRegisterForm()
template_data['form'] = form
return render(request, 'virtualclinic/register.html', template_data)
def users_view(request):
# Authentication check.
authentication_result = views.authentication_check(request,
[Account.ACCOUNT_ADMIN])
if authentication_result is not None:
return authentication_result
# Get the template data from the session
template_data = views.parse_session(request)
# Proceed with the rest of the view
if request.method == 'POST':
pk = request.POST['pk']
role = request.POST['role']
account = Account.objects.get(pk=pk)
if account is not None:
account.role = role
account.save()
logger.log(Action.ACTION_ADMIN,
'Admin modified ' + account.user.username + "'s role",
request.user.account)
template_data[
'alert_success'] = "Updated" + account.user.username + "'s role!"
# Parse search sorting
template_data['query'] = Account.objects.filter(
archive=False).order_by('-role')
return render(request, 'virtualclinic/admin/users.html', template_data)
def monitor(self):
"""
internal heartbeat from Cherrypy.process.plugins.Monitor
"""
self.stat.heartbeat.last = time.time()
#alive = 0
#dead = 0
if self.stat.next_report < self.stat.heartbeat.last:
logger.log("type=status-report", **self.status_report())
def register_user(email, password, firstname, lastname, role, speciality=None):
user = User.objects.create_user(email.lower(), email.lower(), password)
profile = Profile(firstname=firstname,
lastname=lastname,
speciality=speciality)
profile.save()
account = Account(role=role, profile=profile, user=user)
account.save()
medical_info = MedicalInfo(account=account)
medical_info.save()
logger.log(Action.ACTION_ACCOUNT, "Account registered", account)
return user
def update_view(request):
# Authentication check
authentication_result = views.authentication_check(
request,
[Account.ACCOUNT_PATIENT, Account.ACCOUNT_DOCTOR, Account.ACCOUNT_LAB])
if authentication_result is not None:
return authentication_result
# Validation Check. Make sure an appointment exists for the given pk.
if 'pk' in request.GET:
if request.user.account.role != Account.ACCOUNT_DOCTOR:
request.session[
'alert_danger'] = "You don't have permission to view the page."
return HttpResponseRedirect('/error/denied/')
pk = request.GET['pk']
try:
medicalinfo = MedicalInfo.objects.get(pk=pk)
except Exception:
request.session[
'alert_danger'] = "The requested medical info doesn't exist."
return HttpResponseRedirect('/error/denied/')
else:
medicalinfo = MedicalInfo.objects.get(account=request.user.account)
# Get template data from the session
template_data = views.parse_session(request,
{'form_button': "Update Medical Info"})
if 'pk' in request.GET:
template_data['form_action'] = "?pk=" + pk
# Proceed with rest of the view
request.POST._mutable = True
request.POST['account'] = medicalinfo.account.pk
if request.method == 'POST':
form = MedicalInfoForm(request.POST)
if form.is_valid():
form.assign(medicalinfo)
medicalinfo.save()
logger.log(Action.ACTION_MEDICALINFO, 'Medical Info Updated',
request.user.account)
template_data[
'alert_success'] = "The medical info has been updated"
else:
form = MedicalInfoForm(medicalinfo.get_populated_fields())
template_data['form'] = form
form.disable_field('account')
return render(request, 'virtualclinic/medicalinfo/update.html',
template_data)
def create_view(request):
# Authentication Check
authentication_result = views.authentication_check(
request, [Account.ACCOUNT_DOCTOR])
if authentication_result is not None:
return authentication_result
# Get template data from session
template_data = views.parse_session(request,
{'form_button': "Add Prescription"})
default = {}
if request.user.account.role == Account.ACCOUNT_DOCTOR:
default['doctor'] = request.user.account.pk
if 'date' not in request.POST:
default['date'] = datetime.now().strftime("%Y-%m-%d")
request.POST._mutable = True
request.POST.update(default)
form = PrescriptionForm(request.POST)
if request.method == 'POST':
if form.is_valid():
pres = Prescription(
patient=form.cleaned_data['patient'],
doctor=form.cleaned_data['doctor'],
date=form.cleaned_data['date'],
medication=form.cleaned_data['medication'],
strength=form.cleaned_data['strength'],
instruction=form.cleaned_data['instruction'],
refill=form.cleaned_data['refill'],
)
pres.save()
logger.log(Action.ACTION_PRESCRIPTION, 'Prescription Created',
request.user.account)
form = PrescriptionForm(
default) # Clean form data when page is redisplayed
form._errors = {}
request.session[
'alert_success'] = "Successfully added the prescription."
return HttpResponseRedirect('/prescription/list/')
else:
form._errors = {}
if request.user.account.role == Account.ACCOUNT_DOCTOR:
form.disable_field('doctor')
form.date = datetime.today()
template_data['form'] = form
return render(request, 'virtualclinic/prescription/create.html',
template_data)
def logout_view(request):
if request.user.is_authenticated:
logger.log(Action.ACTION_ACCOUNT, "Account logout",
request.user.account)
# Django deletes the session on logout, so we need to preserve any alerts currently waiting to be displayed
saved_data = {}
if request.session.has_key('alert_success'):
saved_data['alert_success'] = request.session['alert_success']
else:
saved_data['alert_success'] = "You have successfully logged out."
if request.session.has_key('alert_danger'):
saved_data['alert_danger'] = request.session['alert_danger']
logout(request)
if 'alert_success' in saved_data:
request.session['alert_success'] = saved_data['alert_success']
if 'alert_danger' in saved_data:
request.session['alert_danger'] = saved_data['alert_danger']
return HttpResponseRedirect('/')
def parse_symptom_delete(request):
# Authentication check.
authentication_result = views.authentication_check(request, [Account.ACCOUNT_ADMIN])
if authentication_result is not None:
return authentication_result
# Get the template data from the session
template_data = views.parse_session(request)
# Proceed with the rest of the view
if request.method == 'POST':
if 'delete' in request.POST and 'pk' in request.POST:
pk = request.POST['pk']
try:
symptom = Symptom.objects.get(pk=pk)
except Exception:
template_data['alert_danger'] = "Unable to delete the symptom. Please try again later."
return
symptom.delete()
logger.log(Action.ACTION_ADMIN, 'Symptom cancelled', request.user.account)
template_data['alert_success'] = "The symptom has been deleted."
return HttpResponseRedirect('/admin/symptom/')
def restore_user(request):
# Authentication check.
authentication_result = views.authentication_check(request,
[Account.ACCOUNT_ADMIN])
if authentication_result is not None:
return authentication_result
# Get the template data from the session
template_data = views.parse_session(request)
# Proceed with the rest of the view
if request.method == 'POST':
if 'restore' in request.POST and 'pk' in request.POST:
pk = request.POST['pk']
try:
user = Account.objects.get(pk=pk)
except Exception:
template_data[
'alert_danger'] = "Unable to delete the user. Please try again later"
return HttpResponseRedirect('/admin/users')
user.archive = False
user.save()
logger.log(Action.ACTION_ADMIN, 'Admin restored the user', user)
url = 'https://evoluzy.et.r.appspot.com/patient/'
x = requests.get(url, params={'patientId': user.profile.id})
patient_dict = json.loads(x.text)
url = 'https://evoluzy.et.r.appspot.com/patient/'
myobj = {
"patientId": patient_dict['patientId'],
"isApproved": patient_dict['isApproved'],
"isArchived": False,
"patientName": patient_dict['patientName'],
"healthData": patient_dict['healthData']
}
x = requests.put(url, json=myobj)
print(x.text)
template_data['alert_success'] = "The user has been restored."
return HttpResponseRedirect('/admin/users')
return HttpResponseRedirect('/admin/users')
def restore_user(request):
# Authentication check.
authentication_result = views.authentication_check(request, [Account.ACCOUNT_ADMIN])
if authentication_result is not None:
return authentication_result
# Get the template data from the session
template_data = views.parse_session(request)
# Proceed with the rest of the view
if request.method == 'POST':
if 'restore' in request.POST and 'pk' in request.POST:
pk = request.POST['pk']
try:
user = Account.objects.get(pk=pk)
except Exception:
template_data['alert_danger'] = "Unable to delete the user. Please try again later"
return HttpResponseRedirect('/admin/users')
user.archive = False
user.save()
logger.log(Action.ACTION_ADMIN, 'Admin restored the user',user)
template_data['alert_success'] = "The user has been restored."
return HttpResponseRedirect('/admin/users')
return HttpResponseRedirect('/admin/users')
def update_view(request):
# Authentication check
authentication_result = views.authentication_check(request, None, ['pk'])
if authentication_result is not None:
return authentication_result
# Validation check. Make sure a medical test exists for given pk.
pk = request.GET['pk']
try:
medicaltest = MedicalTest.objects.get(pk=pk)
except Exception:
request.session['alert_danger'] = "The requested medical test does not exist"
return HttpResponseRedirect('/error/denied')
# Get the template data from the session
template_data = views.parse_session(
request,
{
'form_button':"Update Medical Test",
'form_action':"?pk="+pk,
'medtest':medicaltest
})
# Proceed with rest of view
request.POST._mutable = True
if request.user.account.role == Account.ACCOUNT_DOCTOR:
request.POST['doctor'] = request.user.account.pk
if request.method == 'POST':
form = MedTestForm(request.POST)
if form.is_valid():
form.assign(medicaltest)
medicaltest.save()
logger.log(Action.ACTION_MEDTEST, 'Medical test Updated', request.user.account)
template_data['alert_success'] = "Medical test has been updated"
template_data['form'] = form
else:
form = MedTestForm(medicaltest.get_populated_fields())
if request.user.account.role == Account.ACCOUNT_DOCTOR:
form.disable_field('doctor')
template_data['form'] = form
return render(request,'virtualclinic/medtest/update.html', template_data)
def update_view(request):
# Authentication check
authentication_result = views.authentication_check(request, None, ['pk'])
if authentication_result is not None:
return authentication_result
# Validation check. Make sure a prescription exists for given pk.
pk = request.GET['pk']
try:
prescription = Prescription.objects.get(pk=pk)
except Exception:
request.session[
'alert_danger'] = "The requested prescription does not exist"
return HttpResponseRedirect('/error/denied')
# Get the template data from the session
template_data = views.parse_session(
request, {
'form_button': "Update Prescription",
'form_action': "?pk=" + pk,
'prescription': prescription
})
# Proceed with rest of view
request.POST._mutable = True
if request.method == 'POST':
form = PrescriptionForm(request.POST)
if form.is_valid():
form.assign(prescription)
prescription.save()
logger.log(Action.ACTION_PRESCRIPTION, 'Prescription Updated',
request.user.account)
template_data['alert_success'] = "Prescription has been updated"
template_data['form'] = form
else:
form = PrescriptionForm(prescription.get_populated_fields())
template_data['form'] = form
return render(request, 'virtualclinic/prescription/update.html',
template_data)
def list_view(request):
# Authentication check
authentication_result = views.authentication_check(request, [
Account.ACCOUNT_DOCTOR, Account.ACCOUNT_PATIENT,
Account.ACCOUNT_CHEMIST
])
if authentication_result is not None:
return authentication_result
# get template data from session
template_data = views.parse_session(request)
# proceed with rest of the view
if request.method == 'POST':
if 'delete' in request.POST and 'pk' in request.POST:
pk = request.POST['pk']
try:
prescription = Prescription.objects.get(pk=pk)
prescription.active = False
prescription.save()
logger.log(Action.ACTION_PRESCRIPTION,
'Prescription Cancelled', request.user.account)
template_data[
'alert_success'] = "The prescription has been deleted."
except Exception:
template_data[
'alert_danger'] = "Unable to delete the prescription. Please try again later."
if request.user.account.role == Account.ACCOUNT_DOCTOR:
prescriptions = Prescription.objects.filter(
doctor=request.user.account)
elif request.user.account.role == Account.ACCOUNT_PATIENT:
prescriptions = Prescription.objects.filter(
patient=request.user.account)
else:
prescriptions = Prescription.objects.all()
template_data['query'] = prescriptions.order_by('date')
return render(request, 'virtualclinic/prescription/list.html',
template_data)
def start(self, test=True):
"""
Startup script for webhook routing.
Called from agent start
"""
cherrypy.log = logger.CherryLog()
cherrypy.config.update({
'log.screen': False,
'log.access_file': '',
'log.error_file': ''
})
cherrypy.engine.unsubscribe('graceful', cherrypy.log.reopen_files)
logging.config.dictConfig({
'version': 1,
'formatters': {
'custom': {
'()': 'server.logger.Logger'
}
},
'handlers': {
'console': {
'level':'INFO',
'class': 'server.logger.Logger',
'formatter': 'custom',
'stream': 'ext://sys.stdout'
}
},
'loggers': {
'': {
'handlers': ['console'],
'level': 'INFO'
},
'cherrypy.access': {
'handlers': ['console'],
'level': 'INFO',
'propagate': False
},
'cherrypy.error': {
'handlers': ['console'],
'level': 'INFO',
'propagate': False
},
}
})
# lots of legacy stuff here which isn't used
defaults = {
'deploy_ver': 0, # usable for deployment tools
'server': {
'route_base': '/api/v1',
'port': 64000,
'host': '0.0.0.0'
},
'heartbeat': 10,
'status_report': 3600, # every hour
'requestid': True,
'refresh_maps': 300,
'cache': {
'housekeeper': 60,
'policies': 300,
'sessions': 300,
'groups': 300
},
'auth': {
'expires': 300
}
}
cfgin = None
# try docker secrets
if os.path.exists("/run/secrets/SERVER_CONFIG"):
with open("/run/secrets/SERVER_CONFIG") as infile:
cfgin = infile.read()
# try environ
if not cfgin:
cfgin = os.environ.get('SERVER_CONFIG')
if cfgin:
try:
cfgin = json2data(base64.b64decode(cfgin))
except: # pylint: disable=bare-except
try:
cfgin = json2data(cfgin)
except Exception as err: # pylint: disable=broad-except
traceback.print_exc()
logger.abort("Cannot process SERVER_CONFIG: " + str(err) + " from " + cfgin)
conf = Dict(dictlib.union(defaults, cfgin))
else:
logger.log("Unable to find configuration, using defaults!")
conf = Dict(defaults)
# cherry py global
cherry_conf = {
'server.socket_port': 64000,
'server.socket_host': '0.0.0.0'
}
if dictlib.dig_get(conf, 'server.port'): # .get('port'):
cherry_conf['server.socket_port'] = int(conf.server.port)
if dictlib.dig_get(conf, 'server.host'): # .get('host'):
cherry_conf['server.socket_host'] = conf.server.host
# if production mode
if test:
logger.log("Test mode enabled", type="notice")
conf['test_mode'] = True
else:
cherry_conf['environment'] = 'production'
conf['test_mode'] = False
sys.stdout.flush()
cherrypy.config.update(cherry_conf)
cherrypy.config.update({'engine.autoreload.on': False})
self.conf = conf
sys.path.append('.')
# # eventually
# for mod in self.endpoint_names:
# self.add_endpoint(mod)
# hack for now
# from . import polyform as polyform
from server.endpoints import polyform
self.add_endpoint('polyform', polyform)
# startup cleaning interval
def housekeeper(server):
for endpoint in server.endpoints:
try:
endpoint.handler.housekeeper(server)
except: # pylint: disable=bare-except
traceback.print_exc()
timeinterval.start(conf.auth.expires * 1000, housekeeper, self)
# mount routes
cherrypy.tree.mount(http.Health(server=self),
conf.server.route_base + "/health",
self.endpoint_conf)
int_mon = cherrypy.process.plugins.Monitor(cherrypy.engine,
self.monitor,
frequency=conf.heartbeat/2)
int_mon.start()
# whew, now start the server
logger.log("Base path={}".format(conf.server.route_base), type="notice")
cherrypy.engine.start()
cherrypy.engine.block()
def update_view(request):
# Authentication check
authentication_result = views.authentication_check(request, None, ['pk'])
if authentication_result is not None:
return authentication_result
# Validation check. Make sure appointment exists for given pk
pk = request.GET['pk']
try:
appointment = Appointment.objects.get(pk=pk)
except Exception:
request.session[
'alert_danger'] = "The requested appointment does not exist."
return HttpResponseRedirect('/error/denied/')
# Get template data from session
template_data = views.parse_session(
request, {
'form_button': "Update Appointment",
'form_action': "?pk=" + pk,
'appointment': appointment
})
# Proceed with rest of the view
request.POST._mutable = True
if request.user.account.role == Account.ACCOUNT_PATIENT:
request.POST['patient'] = request.user.account.pk
elif request.user.account.role == Account.ACCOUNT_DOCTOR:
request.POST['doctor'] = request.user.account.pk
if request.method == 'POST':
form = AppointmentForm(request.POST)
if form.is_valid():
form.assign(appointment)
if Appointment.objects.filter(
~Q(pk=appointment.pk), Q(status="Active"),
Q(doctor=appointment.doctor)
| Q(patient=appointment.patient),
Q(startTime__range=(appointment.startTime,
appointment.endTime))
| Q(endTime__range=(appointment.startTime,
appointment.endTime))).count():
form.mark_error(
'startTime',
'This time conflicts with another appointment.')
form.mark_error(
'endTime', 'This time conflicts with another appointment.')
else:
appointment.save()
logger.log(Action.ACTION_APPOINTMENT, 'Appointment Updated',
request.user.account)
template_data[
'alert_success'] = "The appointment has been updated!"
template_data['form'] = form
if request.user.account.role == Account.ACCOUNT_PATIENT:
message.send_appointment_update(request, appointment,
appointment.doctor)
elif request.user.account.role == Account.ACCOUNT_DOCTOR:
message.send_appointment_update(request, appointment,
appointment.patient)
else:
message.send_appointment_update(request, appointment,
appointment.patient)
message.send_appointment_update(request, appointment,
appointment.doctor)
else:
form = AppointmentForm(appointment.get_populated_fields())
if request.user.account.role == Account.ACCOUNT_PATIENT:
form.disable_field('patient')
elif request.user.account.role == Account.ACCOUNT_DOCTOR:
form.disable_field('doctor')
template_data['form'] = form
return render(request, 'virtualclinic/appointment/update.html',
template_data)
def create_view(request):
# Authentication check
authentication_result = views.authentication_check(
request, [Account.ACCOUNT_PATIENT, Account.ACCOUNT_DOCTOR])
if authentication_result is not None:
return authentication_result
# Get template data from session
template_data = views.parse_session(request, {'form_button': "Create"})
# Proceed with rest of the view
default = {}
if request.user.account.role == Account.ACCOUNT_PATIENT:
default['patient'] = request.user.account.pk
if 'doctor' not in request.POST and request.user.account.profile.primaryCareDoctor is not None:
default[
'doctor'] = request.user.account.profile.primaryCareDoctor.pk
elif request.user.account.role == Account.ACCOUNT_DOCTOR:
default['doctor'] = request.user.account.pk
if 'hospital' not in request.POST and request.user.account.profile.prefHospital is not None:
default['hospital'] = request.user.account.profile.prefHospital.pk
request.POST._mutable = True
request.POST.update(default)
form = AppointmentForm(request.POST)
if request.method == 'POST':
if form.is_valid():
appointment = form.generate()
if Appointment.objects.filter(
Q(status="Active"),
Q(doctor=appointment.doctor)
| Q(patient=appointment.patient),
Q(startTime__range=(appointment.startTime,
appointment.endTime))
| Q(endTime__range=(appointment.startTime,
appointment.endTime))).count():
form.mark_error(
'startTime',
'this time conflicts with another appointment')
form.mark_error(
'endTime', 'this time conflicts with another appointment')
else:
appointment.save()
logger.log(Action.ACTION_APPOINTMENT, 'Appointment created',
request.user.account)
form = AppointmentForm(
default) # clean form when page is re displayed
form._errors = {}
request.session[
'alert_success'] = "Successfully created your appointment!"
if request.user.account.role == Account.ACCOUNT_DOCTOR:
message.send_appointment_create(request, appointment,
appointment.patient)
elif request.user.account.role == Account.ACCOUNT_PATIENT:
message.send_appointment_create(request, appointment,
appointment.doctor)
else:
message.send_appointment_create(request, appointment,
appointment.patient)
message.send_appointment_create(request, appointment,
appointment.doctor)
return HttpResponseRedirect('/appointment/list/')
else:
form._errors = {}
if request.user.account.role == Account.ACCOUNT_PATIENT:
form.disable_field('patient')
elif request.user.account.role == Account.ACCOUNT_DOCTOR:
form.disable_field('doctor')
template_data['form'] = form
return render(request, 'virtualclinic/appointment/create.html',
template_data)
def send_message(sender, target, header, body):
message = Message(target=target, sender=sender, header=header, body=body)
message.save()
logger.log(Action.ACTION_MESSAGE, 'Message sent', sender)
