def save_token(token_props, req, *args, **kwargs): """ Saves token to the database """ result_token = None token_id = token_props.get('id') token = OauthAccessTokenEntity.get_by_id(token_id) # log.debug("From {} got {}".format(token_id, token)) if token and not token.is_expired(): # log.debug("Reuse access token: {} expiring on {} ({} seconds left)" # .format(token.id, token.expires, token.expires_in)) result_token = token else: access_token = utils.generate_token() # access_token = utils.generate_token_urandom(TOKEN_LENGTH) expires = datetime.utcnow() + timedelta(seconds=TOKEN_EXPIRES_SECONDS) added_at = utils.get_db_friendly_date_time() if token: result_token = OauthAccessTokenEntity.update( token, access_token=access_token, expires=expires, added_at=added_at) else: result_token = OauthAccessTokenEntity.create( access_token=access_token, token_type=TOKEN_TYPE_BEARER, _scopes='', expires=expires, client_id=req.client.client_id, added_at=added_at) # log.info("return from save_token: {}".format(result_token)) return result_token
def create_partners(self): """ Create rows """ added_date = utils.get_db_friendly_date_time() partner_uf = PartnerEntity.create( partner_code="UF", partner_description="University of Florida", partner_added_at=added_date) partner_fh = PartnerEntity.create( partner_code="FH", partner_description="Florida Hospital", partner_added_at=added_date) self.assertIsNotNone(partner_uf.id) self.assertIsNotNone(partner_fh.id) self.assertEquals("UF", partner_uf.partner_code) self.assertEquals("FH", partner_fh.partner_code) # verify that more than one with self.assertRaises(MultipleResultsFound): PartnerEntity.query.filter( PartnerEntity. partner_description.like( '%Florida%')).one()
def create_sample_data(self): """ Add some data """ added_date = utils.get_db_friendly_date_time() sample_data = [ {"first": "Aida", "last": " Xenon", "dob": "1910-11-12", "zip": "19116", "city": "GAINESVILLE"}, {"first": "aida", "last": "xeNon ", "dob": "1910/11/12", "zip": "19116", "city": "gainesville"}, {"first": "AIDA", "last": "XENON ", "dob": "1910:11:12 ", "zip": "19116", "city": "Gainesville"}, {"first": "AiDa", "last": "XEnON ", "dob": "19101112 ", "zip": "19116", "city": "gainesviLLe"}, {"first": "John", "last": "Doe", "dob": "1900-01-01", "zip": "32606", "city": "Palatca"}, {"first": "JOHN", "last": "DOE", "dob": "1900-01-01", "zip": "32607", "city": "Palatca"}, ] partner = PartnerEntity.query.filter_by( partner_code='UF').one() # Note: first four entries produce the same hashes (aka chunks) for person_data in sample_data: person_orig = Person(person_data) person = Person.get_prepared_person(person_data) pers_uuid = utils.get_uuid_bin() hashes = get_person_hash(person, [RULE_CODE_F_L_D_Z, RULE_CODE_L_F_D_Z]) for rule_id, ahash in hashes.items(): link = LinkageEntity.create( partner_id=partner.id, linkage_uuid=pers_uuid, linkage_hash=ahash, linkage_addded_at=added_date) self.assertIsNotNone(link) links_by_hash = LinkageEntity.query.filter_by( linkage_hash=ahash).all() verbose("==> Found {} link(s) for [{}] using hash: {}" .format( len(links_by_hash), person_orig, hexlify(ahash)))
def create_partners(self): """ Create rows """ added_date = utils.get_db_friendly_date_time() partner_uf = PartnerEntity.create( partner_code="UF", partner_description="University of Florida", partner_added_at=added_date) partner_fh = PartnerEntity.create( partner_code="FH", partner_description="Florida Hospital", partner_added_at=added_date) self.assertIsNotNone(partner_uf.id) self.assertIsNotNone(partner_fh.id) self.assertEquals("UF", partner_uf.partner_code) self.assertEquals("FH", partner_fh.partner_code) # verify that more than one with self.assertRaises(MultipleResultsFound): PartnerEntity.query.filter( PartnerEntity.partner_description.like('%Florida%')).one()
def create_oauth_users(self): """ Add user, role, user_role Note: partners should exist """ added_at = utils.get_db_friendly_date_time() expires_date = utils.get_expiration_date(10) expires_date2 = utils.get_expiration_date(0) ############## # add role row role = OauthRoleEntity.create( role_code='root', role_description='super-user can do xyz...' ) self.assertEquals(1, role.id) role = OauthRoleEntity.get_by_id(1) self.assertIsNotNone(role) verbose(role) ############## # add user row user = OauthUserEntity.create( email='*****@*****.**', password_hash='$6$rounds=666140$vQVDNQUwZCSDY0u7$kqmaQjQnYwWz9EQlms99UQDYaphVBwujnUs1H3XdhT741pY1HPirG1Y.oydcw3QtQnaMyVOspVZ20Dij7f24A/', # NOQA added_at=added_at ) self.assertEquals(1, user.id) verbose(user) ############## # add user_role row partner = PartnerEntity.query.filter_by(partner_code="UF").one() verbose(partner) user_role = OauthUserRoleEntity.create( partner_id=partner.id, user_id=user.id, role_id=role.id, added_at=added_at ) user_role = OauthUserRoleEntity.get_by_id(1) self.assertIsNotNone(user_role) verbose(user_role) ############## # Verify that the user now is properly mapped to a partner and a role user = OauthUserEntity.get_by_id(1) self.assertIsNotNone(user.partner) self.assertIsNotNone(user.role) verbose(user) ############## # Verify that we can save a client, grant code, access token client = OauthClientEntity.create( client_id='client_1', client_secret='secret_1', user_id=user.id, added_at=added_at) client2 = OauthClientEntity.create( client_id='client_2', client_secret='secret_2', user_id=user.id, added_at=added_at) token = OauthAccessTokenEntity.create( client_id=client.client_id, token_type='Bearer', access_token='access_token_1', refresh_token='refresh_token_1', expires=expires_date, added_at=added_at) token2 = OauthAccessTokenEntity.create( client_id=client2.client_id, token_type='Bearer', access_token='access_token_2', refresh_token='', expires=expires_date2, added_at=added_at) self.assertIsNotNone(client.id) self.assertIsNotNone(client2.id) self.assertIsNotNone(token.id) self.assertIsNotNone(token2.id) # Verify the token properties self.assertIsNotNone(token.client) self.assertIsNotNone(token.client.user) self.assertIsNotNone(token.user) self.assertIsNotNone(token.user.id) ser = token.serialize() self.assertIsNotNone(ser.get('id')) self.assertIsNotNone(ser.get('access_token')) self.assertIsNotNone(ser.get('expires_in')) client = OauthClientEntity.get_by_id(1) client2 = OauthClientEntity.query.filter_by(client_id='client_1').one() role = OauthUserRoleEntity.get_by_id(1) self.assertIsNotNone(client) self.assertIsNotNone(client2) self.assertIsNotNone(role) verbose("Expect client: {}".format(client)) verbose("Expect token: {}".format(token)) verbose("Expect token serialized: {}".format(token.serialize())) verbose("Expect token2 serialized: {}".format(token2.serialize()))
def api_save_patient_hashes(): """ For each chunk save a new uuid or return an existing one from the database. == Example of input json: { "data": { "1": { "1": "b2cdaea3d7c9891b2ed94d1973fe5085183e4bb4bd87b672e066a456ee67bd38" }, "2": { "1": "345b192ae4093dcbc5c914bdcb5e8c41e58162475a295c88b1ce594bd3dd78f7", "2": "1dcce10470c0ea73a8a6287f69f4f862c5e13faea7c11104fae07dbc8d5ce56e" }, "3": { "1": "995b192ae4093dcbc5c914bdcb5e8c41e58162475a295c88b1ce594bd3dd78f7" } } } == To find the rows in the database: select hex(linkage_uuid), hex(linkage_hash) from linkage order by linkage_id; """ auth_pieces = request.headers.get('Authorization').split(' ') log.debug("Authorization_header: {}".format(auth_pieces)) access_token = auth_pieces[1].strip() partner = get_partner_from_token(access_token) json = request.get_json(silent=False) if not json: err = "Invalid json object specified" log.error(err) return utils.jsonify_error(err) result = collections.defaultdict(dict) json_data = json['data'] # patient chunks are received in groups for pat_id, pat_chunks in json_data.items(): # Since there is a chance of duplicate chunks find uniques chunks = list(set(chunk for chunk_num, chunk in pat_chunks.items())) chunks_cache = LinkageEntity.get_chunks_cache(chunks) uuids = LinkageEntity.get_distinct_uuids_for_chunks(chunks_cache) log.debug("Found [{}] matching uuids from [{}] chunks of patient " "[{}]".format(len(uuids), len(chunks), pat_id)) added_date = utils.get_db_friendly_date_time() if len(uuids) == 0: binary_uuid = utils.get_uuid_bin() hex_uuid = utils.hexlify(binary_uuid) log.debug("Generate [{}] for pat_id[{}]".format(pat_id, hex_uuid)) elif len(uuids) == 1: hex_uuid = uuids.pop() binary_uuid = unhexlify(hex_uuid.encode('utf-8')) log.debug("Reuse [{}] for pat_id[{}]".format(pat_id, hex_uuid)) else: log.error("Oops...It looks like we got a collision!" "\n==> chunks: {}\n==> uuids: {}".format(chunks, uuids)) raise Exception("More than one uuid for chunks attributed to " "[{}] patient [{}]".format(partner.partner_code, pat_id)) # update the response json result[pat_id] = {"uuid": hex_uuid} for i, chunk in enumerate(chunks): if chunks_cache.get(chunk): log.debug("Skip chunk [{}] - already linked".format(chunk)) continue # link every chunk to the same uuid binary_hash = unhexlify(chunk.encode('utf-8')) LinkageEntity.create(partner_id=partner.id, linkage_uuid=binary_uuid, linkage_hash=binary_hash, linkage_addded_at=added_date) log.debug("Created link [{}] for [{}]".format(i, chunk)) return utils.jsonify_success(result)
def create_oauth_users(self): """ Add user, role, user_role Note: partners should exist """ added_at = utils.get_db_friendly_date_time() expires_date = utils.get_expiration_date(10) expires_date2 = utils.get_expiration_date(0) ############## # add role row role = OauthRoleEntity.create( role_code='root', role_description='super-user can do xyz...') self.assertEquals(1, role.id) role = OauthRoleEntity.get_by_id(1) self.assertIsNotNone(role) verbose(role) ############## # add user row user = OauthUserEntity.create( email='*****@*****.**', password_hash= '$6$rounds=666140$vQVDNQUwZCSDY0u7$kqmaQjQnYwWz9EQlms99UQDYaphVBwujnUs1H3XdhT741pY1HPirG1Y.oydcw3QtQnaMyVOspVZ20Dij7f24A/', # NOQA added_at=added_at) self.assertEquals(1, user.id) verbose(user) ############## # add user_role row partner = PartnerEntity.query.filter_by(partner_code="UF").one() verbose(partner) user_role = OauthUserRoleEntity.create(partner_id=partner.id, user_id=user.id, role_id=role.id, added_at=added_at) user_role = OauthUserRoleEntity.get_by_id(1) self.assertIsNotNone(user_role) verbose(user_role) ############## # Verify that the user now is properly mapped to a partner and a role user = OauthUserEntity.get_by_id(1) self.assertIsNotNone(user.partner) self.assertIsNotNone(user.role) verbose(user) ############## # Verify that we can save a client, grant code, access token client = OauthClientEntity.create(client_id='client_1', client_secret='secret_1', user_id=user.id, added_at=added_at) client2 = OauthClientEntity.create(client_id='client_2', client_secret='secret_2', user_id=user.id, added_at=added_at) token = OauthAccessTokenEntity.create(client_id=client.client_id, token_type='Bearer', access_token='access_token_1', refresh_token='refresh_token_1', expires=expires_date, added_at=added_at) token2 = OauthAccessTokenEntity.create(client_id=client2.client_id, token_type='Bearer', access_token='access_token_2', refresh_token='', expires=expires_date2, added_at=added_at) self.assertIsNotNone(client.id) self.assertIsNotNone(client2.id) self.assertIsNotNone(token.id) self.assertIsNotNone(token2.id) # Verify the token properties self.assertIsNotNone(token.client) self.assertIsNotNone(token.client.user) self.assertIsNotNone(token.user) self.assertIsNotNone(token.user.id) ser = token.serialize() self.assertIsNotNone(ser.get('id')) self.assertIsNotNone(ser.get('access_token')) self.assertIsNotNone(ser.get('expires_in')) client = OauthClientEntity.get_by_id(1) client2 = OauthClientEntity.query.filter_by(client_id='client_1').one() role = OauthUserRoleEntity.get_by_id(1) self.assertIsNotNone(client) self.assertIsNotNone(client2) self.assertIsNotNone(role) verbose("Expect client: {}".format(client)) verbose("Expect token: {}".format(token)) verbose("Expect token serialized: {}".format(token.serialize())) verbose("Expect token2 serialized: {}".format(token2.serialize()))
def create_sample_data(self): """ Add some data """ added_date = utils.get_db_friendly_date_time() sample_data = [ { "first": "Aida", "last": " Xenon", "dob": "1910-11-12", "zip": "19116", "city": "GAINESVILLE" }, { "first": "aida", "last": "xeNon ", "dob": "1910/11/12", "zip": "19116", "city": "gainesville" }, { "first": "AIDA", "last": "XENON ", "dob": "1910:11:12 ", "zip": "19116", "city": "Gainesville" }, { "first": "AiDa", "last": "XEnON ", "dob": "19101112 ", "zip": "19116", "city": "gainesviLLe" }, { "first": "John", "last": "Doe", "dob": "1900-01-01", "zip": "32606", "city": "Palatca" }, { "first": "JOHN", "last": "DOE", "dob": "1900-01-01", "zip": "32607", "city": "Palatca" }, ] partner = PartnerEntity.query.filter_by(partner_code='UF').one() # Note: first four entries produce the same hashes (aka chunks) for person_data in sample_data: person_orig = Person(person_data) person = Person.get_prepared_person(person_data) pers_uuid = utils.get_uuid_bin() hashes = get_person_hash(person, [RULE_CODE_F_L_D_Z, RULE_CODE_L_F_D_Z]) for rule_id, ahash in hashes.items(): link = LinkageEntity.create(partner_id=partner.id, linkage_uuid=pers_uuid, linkage_hash=ahash, linkage_addded_at=added_date) self.assertIsNotNone(link) links_by_hash = LinkageEntity.query.filter_by( linkage_hash=ahash).all() verbose("==> Found {} link(s) for [{}] using hash: {}".format( len(links_by_hash), person_orig, hexlify(ahash)))
def api_save_patient_hashes(): """ For each chunk save a new uuid or return an existing one from the database. == Example of input json: { "data": { "1": { "1": "b2cdaea3d7c9891b2ed94d1973fe5085183e4bb4bd87b672e066a456ee67bd38" }, "2": { "1": "345b192ae4093dcbc5c914bdcb5e8c41e58162475a295c88b1ce594bd3dd78f7", "2": "1dcce10470c0ea73a8a6287f69f4f862c5e13faea7c11104fae07dbc8d5ce56e" }, "3": { "1": "995b192ae4093dcbc5c914bdcb5e8c41e58162475a295c88b1ce594bd3dd78f7" } } } == To find the rows in the database: select hex(linkage_uuid), hex(linkage_hash) from linkage order by linkage_id; """ auth_pieces = request.headers.get('Authorization').split(' ') log.debug("Authorization_header: {}".format(auth_pieces)) access_token = auth_pieces[1].strip() partner = get_partner_from_token(access_token) json = request.get_json(silent=False) if not json: err = "Invalid json object specified" log.error(err) return utils.jsonify_error(err) result = collections.defaultdict(dict) json_data = json['data'] # patient chunks are received in groups for pat_id, pat_chunks in json_data.items(): # Since there is a chance of duplicate chunks find uniques chunks = list(set(chunk for chunk_num, chunk in pat_chunks.items())) chunks_cache = LinkageEntity.get_chunks_cache(chunks) uuids = LinkageEntity.get_distinct_uuids_for_chunks(chunks_cache) log.debug("Found [{}] matching uuids from [{}] chunks of patient " "[{}]".format(len(uuids), len(chunks), pat_id)) added_date = utils.get_db_friendly_date_time() if len(uuids) == 0: binary_uuid = utils.get_uuid_bin() hex_uuid = utils.hexlify(binary_uuid) log.debug("Generate [{}] for pat_id[{}]".format(pat_id, hex_uuid)) elif len(uuids) == 1: hex_uuid = uuids.pop() binary_uuid = unhexlify(hex_uuid.encode('utf-8')) log.debug("Reuse [{}] for pat_id[{}]".format(pat_id, hex_uuid)) else: log.error("Oops...It looks like we got a collision!" "\n==> chunks: {}\n==> uuids: {}".format(chunks, uuids)) raise Exception("More than one uuid for chunks attributed to " "[{}] patient [{}]" .format(partner.partner_code, pat_id)) # update the response json result[pat_id] = {"uuid": hex_uuid} for i, chunk in enumerate(chunks): if chunks_cache.get(chunk): log.debug("Skip chunk [{}] - already linked".format(chunk)) continue # link every chunk to the same uuid binary_hash = unhexlify(chunk.encode('utf-8')) LinkageEntity.create( partner_id=partner.id, linkage_uuid=binary_uuid, linkage_hash=binary_hash, linkage_addded_at=added_date) log.debug("Created link [{}] for [{}]".format(i, chunk)) return utils.jsonify_success(result)