def get_data(self, key):
bins = self._get_one(key)
if bins == None:
return None
data = bins.get('data')
if data == None:
logging.error('Missed data bin')
raise APILogicalError('Missed data bin')
chunks_count = bins.get('chunks_count')
if not chunks_count or chunks_count == 1:
return bins.get('data')
result = bytearray(data)
chunk_keys = list()
for i in range(1, chunks_count):
chunk_keys.append(self._chunk_subkey(key, i))
chunks = self._get_many(chunk_keys)
for chunk in chunks:
if not chunk:
logging.error('One of data chunks missed')
raise APILogicalError('One of data chunks missed')
data = chunk.get('data')
if not data:
logging.error('Missed data bin')
raise APILogicalError('Missed data bin')
result.extend(data)
return result
def get_info(self, user_id):
info_key = (self._namespace, self._info_set, str(user_id))
record = self._aerospike_connector.get_bins(info_key)
if record == None:
raise APILogicalError('User {} not found'.format(user_id))
try:
info = UserInfo()
info.decode(record)
except Exception as ex:
logging.error('Bad info record, {}'.format(ex))
raise APILogicalError('Bad info record, {}'.format(ex))
return info
def _run_session(self):
info = self._users_engine.get_info(self._params.user_id)
if info == None:
raise APILogicalError('User not found')
# TODO remove facebook_access_token from result
result = {
'user_id': info.user_id,
'facebook_user_id': info.facebook_user_id,
'facebook_access_token': info.facebook_access_token,
'name': info.name,
'username': info.username,
'email': info.email
}
if 'meta_blob' in self._params.properties:
result['meta_blob'] = self._users_engine.get_meta(
self._params.user_id)
if 'picture_blob' in self._params.properties:
result['picture_blob'] = self._users_engine.get_picture(
self._params.user_id)
if 'friends' in self._params.properties:
facebook_user_id = result['facebook_user_id']
facebook_access_token = result['facebook_access_token']
if facebook_user_id != None and facebook_access_token != None:
result['friends'] = self._get_friends_fb(
info.user_id, facebook_user_id, facebook_access_token)
else:
result['friends'] = list()
return result
def _run_session(self):
# Check user credentials
self._access_rules.check_can_view_private_info(self._params.user_token,
self._params.user_id)
info = self._users_engine.get_info(self._params.user_id)
if info == None:
raise APILogicalError('User {} not found'.format(
self._params.user_id))
friends = list()
cursor = ''
has_next = False
if info.facebook_user_id != None and info.facebook_access_token != None:
friends, cursor, has_next = self._get_fb_friends(
info.facebook_user_id, info.facebook_access_token)
result = {
'success': True,
'data': friends,
'paging': {
'cursor': cursor,
'has_next': has_next
}
}
return result
def _run_session(self):
user_id = self._params.user_token.user_id
# Check user credentials
self._access_rules.check_can_edit_user_info(self._params.user_token,
user_id)
user_info = self._users_engine.get_info(user_id)
if user_info == None:
raise APILogicalError('User not found')
info_updated = False
if self._params.name != None:
user_info.name = self._params.name
info_updated = True
if self._params.username != None:
user_info.username = self._params.username
info_updated = True
if self._params.email != None:
user_info.email = self._params.email
info_updated = True
if info_updated:
self._users_engine.put_info(user_info)
if self._params.meta_blob:
self._users_engine.put_meta(user_id, self._params.meta_blob)
if self._params.picture_blob != None:
self._users_engine.put_picture(user_id, self._params.picture_blob)
result = {'success': True, 'user_token': self._params.user_token_str}
return result
def _get_items_from_list(self, user_key, limit, cursor_code):
result = DataPage()
cursor = Cursor()
cursor.decode(cursor_code)
items_count = self._aerospike_connector.list_size(user_key, 'data')
query_count = limit
if cursor.offset + query_count >= items_count:
query_count = items_count - cursor.offset
result.has_next = False
else:
result.has_next = True
if query_count <= 0:
return result
result.data = self._aerospike_connector.list_get_range(user_key, 'data', cursor.offset, query_count)
if result.data == None:
raise APILogicalError('Can\'t get items range from database')
next_cursor = Cursor(0, cursor.offset + query_count)
result.cursor_code = next_cursor.encode()
return result
def _remove_item_from_list(self, user_key, item):
items_count = self._aerospike_connector.list_size(user_key, 'data')
if items_count == 0:
raise APILogicalError('Can\'t remove item from empty list')
items = self._aerospike_connector.list_get_range(user_key, 'data', 0, items_count)
for i in range(len(items) - 1, -1, -1):
if items[i] == item:
self._aerospike_connector.list_remove(user_key, 'data', i)
def external_to_local_id(self, external_id):
if external_id == None:
return None
link_key = (self._namespace, self._external_to_local_set, external_id)
record = self._aerospike_connector.get_bins(link_key)
if record == None:
return None
user_id = record.get('user_id')
if user_id == None:
raise APILogicalError('External link record({}) has no user_id bin'.format(external_id))
return int(user_id)
def decode(self, secret, cipher):
try:
coder = AESCipher(secret)
data = coder.decrypt(cipher)
parsed = json.loads(data)
self.code = parsed.get('c')
self.email = parsed.get('em')
self.expiration_timestamp = parsed.get('et')
except Exception as ex:
logging.error(ex)
raise APILogicalError('Can\'t decode auth code')
def add_private_access(self, user_id, sign_id):
global_record = self._aerospike_connector.get_bins((self._namespace, self._global_set, str(sign_id)))
if global_record == None:
raise APILogicalError('Record was not found in global index')
private_record = {
'user_id': str(user_id),
'sign_id': str(sign_id),
'location': global_record['location'],
'features': global_record['features']
}
pk = '{}:{}'.format(user_id, sign_id)
self._aerospike_connector.put_bins((self._namespace, self._private_set, pk), private_record)