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)