def handle(self, req): verified_caretaker = pg.patients.Patient.verify_is_my_caretaker( self.cw.get_pgconn(), req.wz_req.args["patient_number"], req.user.person_uuid) if not verified_caretaker: return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, you're not a caretaker for patient {patient_number}!".format(**req.wz_req.args))) else: patient = pg.patients.Patient.by_patient_number( self.cw.get_pgconn(), req.wz_req.args["patient_number"]) return Response.json(dict( success=True, message="Retrieved {0}.".format(patient.display_name), reply_timestamp=datetime.datetime.now(), patient=patient))
def handle(self, req): verified_caretaker = pg.patients.Patient.verify_is_my_caretaker( self.cw.get_pgconn(), req.json["patient_number"], req.user.person_uuid) if not verified_caretaker: return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, you're not a caretaker for patient {patient_number}!".format(**req.json))) else: pe = pg.patients.PatientEvent.insert( self.cw.get_pgconn(), req.json["patient_number"], req.json["event_timestamp"], req.user.person_uuid, req.json["extra_notes"], req.json["extra_data"]) return Response.json(dict( success=True, reply_timestamp=datetime.datetime.now(), message="Stored patient event {0}!".format(pe.patient_event_number), patient_event=pe))
def handle(self, req): try: confirmed_person = pg.people.Person.confirm_email( self.cw.get_pgconn(), req.json["email_address"], req.json["confirmation_code"]) except KeyError as ex: return Response.json(dict( success=False, message=ex.args[0], reply_timestamp=datetime.datetime.now())) else: return Response.json(dict( confirmed_person=confirmed_person, success=True, message="You ({0}) are now confirmed!".format(confirmed_person.display_name), reply_timestamp=datetime.datetime.now()))
def handle(self, req): verified_caretaker = pg.patients.Patient.verify_is_my_caretaker( self.cw.get_pgconn(), req.json["patient_number"], req.user.person_uuid) if not verified_caretaker: return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, you're not a caretaker for patient {patient_number}!".format(**req.json))) else: deleted_patient = pg.patients.Patient.delete_patient( self.cw.get_pgconn(), req.json["patient_number"]) return Response.json(dict( deleted_patient=deleted_patient, success=True, reply_timestamp=datetime.datetime.now(), message="Deleted patient {0}!".format(req.json["patient_number"])))
def handle(self, req): session_from_qs = None if not req.session and "session_uuid" in req.wz_req.args: try: session_uuid = uuid.UUID(req.wz_req.args["session_uuid"]) except ValueError as ex: return Response.json(dict( reply_timestamp=datetime.datetime.now(), success=False, message="Invalid UUID: {0}!".format( req.wz_req.args["session_uuid"]))) else: session_from_qs = pg.sessions.Session.verify_session_uuid( self.cw.get_pgconn(), session_uuid) if session_from_qs or req.session: sesh = session_from_qs or req.session logged_in_person = pg.people.Person.by_person_uuid( self.cw.get_pgconn(), sesh.person_uuid) resp = Response.json(dict( reply_timestamp=datetime.datetime.now(), success=True, message="Verified session is good until {0}.".format( sesh.expires), session=sesh, logged_in_person=logged_in_person)) resp.set_session_cookie( sesh.session_uuid, self.cw.app_secret) return resp else: return Response.json(dict( reply_timestamp=datetime.datetime.now(), success=False, message="Could not verify session"))
def handle(self, req): handler_list = sorted([h for h in self.dispatcher.handlers], key=lambda x: x.__class__.__name__) return Response.tmpl('dashboard/handler-list.html', handler_list=handler_list)
def handle(self, req): email_address = req.json["email_address"].strip() confirmation_code = req.json["confirmation_code"].strip() session = None session = pg.sessions.Session.maybe_start_new_session_after_checking_email_and_confirmation_code( self.cw.get_pgconn(), email_address, confirmation_code, datetime.timedelta(days=3)) if session: person = pg.people.Person.by_person_uuid( self.cw.get_pgconn(), session.person_uuid) log.info("{0} just logged in.".format(person.display_name)) resp = Response.json(dict( reply_timestamp=datetime.datetime.now(), message="Session created and will expire on {0}".format( session.expires), success=True, session=session, person=person)) resp.set_session_cookie( session.session_uuid, self.cw.app_secret) log.debug(resp.headers) return resp else: log.info("Failed login attempt: {0} / {1}".format( email_address, confirmation_code)) return Response.json(dict( message="Sorry, couldn't authenticate!", reply_timestamp=datetime.datetime.now(), success=False))
def get_session_from_cookie_or_json_or_QS(handler_method, self, req): """ This thing sets the session attribute on the request object (req) from either the cookie, or from any JSON post data, or from a query string. I think the request object should figure the stuff about the different location of the session UUID, and then this decorator should only be in charge of just being a gatekeeper... You can test this like so:: $ curl --data '{"session_uuid": "d5e19089-ce27-4ab9-b1d0-129a19c81a94"}' -H "Content-Type: application/json" http://circuit.xps/api/insert-club-fee $ curl http://circuit.xps/api/insert-club-fee?"session_uuid=d5e19089-ce27-4ab9-b1d0-129a19c81a94" $ curl 'http://circuit.xps/api/insert-club-fee' -H 'Cookie: session_uuid=d5e19089-ce27-4ab9-b1d0-129a19c81a94; session_hexdigest=162719e3a569b048b005d6d5140fe884' """ found_session = False if req.user: found_session = True elif req.json and "session_uuid" in req.json: sesh = pg.sessions.Session.verify_session_uuid( self.cw.get_pgconn(), req.json["session_uuid"]) if sesh: req.session = sesh found_session = True elif req.wz_req.args and "session_uuid" in req.wz_req.args: sesh = pg.sessions.Session.verify_session_uuid( self.cw.get_pgconn(), req.wz_req.args["session_uuid"]) if sesh: req.session = sesh found_session = True if found_session: return handler_method(self, req) else: return Response.json(dict( reply_timestamp=datetime.datetime.now(), message="Sorry, you need to log in first!", needs_to_log_in=True, success=False))
def handle(self, req): if not pg.people.Person.email_is_valid(req.json["email_address"]): return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, {email_address} is not a valid email!".format(**req.json))) elif not pg.people.Person.email_address_is_new( self.cw.get_pgconn(), req.json["email_address"]): return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, Somebody else already registered " "email {email_address}!".format(**req.json))) elif req.json["agreed_with_TOS"]: inserted_person = pg.people.Person.insert( self.cw.get_pgconn(), req.json["display_name"], req.json["email_address"], datetime.datetime.now()) inserted_person.send_confirmation_code_via_email( self.cw.make_smtp_connection()) return Response.json(dict( success=True, reply_timestamp=datetime.datetime.now(), inserted_person=inserted_person, message="Go check your email!")) else: return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), inserted_person=inserted_person, message="Sorry, you must agree with the terms of service to use this application"))
def handle(self, req): try: pe = pg.patients.PatientEvent.by_patient_event_number( self.cw.get_pgconn(), req.json["patient_event_number"]) except KeyError as ex: log.error(ex) return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message=ex.args[0])) else: verified_caretaker = pg.patients.Patient.verify_is_my_caretaker( self.cw.get_pgconn(), pe.patient_number, req.user.person_uuid) if not verified_caretaker: return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, you're not a caretaker for patient {0}!".format(pe.patient_number))) else: deleted_patient_event = pg.patients.PatientEvent.delete_patient_event( self.cw.get_pgconn(), req.json["patient_event_number"]) return Response.json(dict( deleted_patient_event=deleted_patient_event, success=True, reply_timestamp=datetime.datetime.now(), message="Deleted patient event {0}!".format(req.json["patient_event_number"])))
def handle(self, req): resp = Response( "200 OK", [ ('Access-Control-Allow-Origin', dict(req.wz_req.headers).get('Origin', '*')), ('Access-Control-Allow-Credentials', 'true'), ("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Engaged-Auth-Token"), ], []) return resp
def handle(self, req): verified_caretaker = pg.patients.Patient.verify_is_my_caretaker( self.cw.get_pgconn(), req.wz_req.args["patient_number"], req.user.person_uuid) if not verified_caretaker: return Response.json(dict( success=False, reply_timestamp=datetime.datetime.now(), message="Sorry, you're not a caretaker for patient {patient_number}!".format(**req.wz_req.args))) else: offset = int(req.wz_req.args.get("offset", 0)) limit = int(req.wz_req.args.get("limit", 10)) patient_events = list(pg.patients.PatientEvent.by_patient_number( self.cw.get_pgconn(), req.wz_req.args["patient_number"], offset, limit)) total_event_count = pg.patients.PatientEvent.count_patient_events( self.cw.get_pgconn(), req.wz_req.args["patient_number"]) return Response.json(dict( success=True, message="Retrieved {0} events of {1} total.".format( len(patient_events), total_event_count), reply_timestamp=datetime.datetime.now(), offset=offset, limit=limit, patient_events=patient_events, total_event_count=total_event_count))
def handle(self, req): try: session = pg.sessions.Session.by_session_uuid( self.cw.get_pgconn(), req.json["session_uuid"]) except KeyError: return Response.json(dict( message="Sorry, could not find session {0}!".format(req.json["session_uuid"]), reply_timestamp=datetime.datetime.now(), success=False)) else: updated_session = session.end_session(self.cw.get_pgconn()) return Response.json(dict( message="Ended session {0}.".format(session.session_uuid), reply_timestamp=datetime.datetime.now(), success=True, session=updated_session))
def handle(self, req): person = pg.people.Person.by_email_address( self.cw.get_pgconn(), req.json["email_address"].strip()) if not person.confirmation_code: person = person.reset_confirmation_code(self.cw.get_pgconn()) person.send_confirmation_code_via_email( self.cw.make_smtp_connection()) return Response.json(dict( message="Sent a confirmation code to {0}!".format(person.email_address), reply_timestamp=datetime.datetime.now(), success=True))
def handle(self, req): handler_name = req.wz_req.args['handler_name'] matching_handler_classes = [ h.__class__ for h in self.dispatcher.handlers if handler_name == h.__class__.__name__ ] log.debug('Found {0} matches for handler name {1}.'.format( len(matching_handler_classes), handler_name)) if len(matching_handler_classes) == 1: hc = matching_handler_classes[0] return Response.plain(inspect.getsource(hc))
def handle(self, req): offset = int(req.wz_req.args.get("offset", 0)) limit = int(req.wz_req.args.get("offset", 10)) patients = list(pg.patients.Patient.patients_for_caretaker( self.cw.get_pgconn(), req.user.person_uuid, offset, limit)) return Response.json(dict( success=True, message="Retrieved {0} patients".format(len(patients)), reply_timestamp=datetime.datetime.now(), offset=offset, limit=limit, patients=patients))
def handle(self, req): new_patient = pg.patients.Patient.insert( self.cw.get_pgconn(), req.json["display_name"], req.json["extra_notes"], req.json["extra_data"]) link = pg.patients.Patient.link_to_caretaker( self.cw.get_pgconn(), new_patient.patient_number, req.user.person_uuid, None, None) return Response.json(dict( success=True, reply_timestamp=datetime.datetime.now(), message="Stored patient {0}!".format(new_patient.display_name), new_patient=new_patient, link=link))
def handle(self, req): return Response.tmpl('mockups/splash.html')
def handle(self, req): return Response.tmpl('dashboard/scratch.html')
def handle(self, req): return Response.json(dict( message="Welcome to the StuhlGang API", success=True, reply_timestamp=datetime.datetime.now()))