def is_valid(user_email: str, project_domain: str) -> bool: """Verify whether a user has an active subscription to a project. Args: user_email: The user's email address. project_domain: The project's domain name. Returns: True if the user has an activate subscription to the project. """ pk = db.PartitionKey(ent.User, user_email) sk_user = db.SortKey(ent.Sub, project_domain) sk_group = db.SortKey(ent.GroupSub, project_domain) pk_cond = cond.Key('PK').eq(str(pk)) sk_cond = cond.Key('SK').eq(str(sk_user)) | cond.Key('SK').eq(str(sk_group)) # noqa 501 key_cond = pk_cond & sk_cond query_arg = db.QueryArg(key_cond, attributes=['IsActive']) subs = get_table().query(query_arg) for s in subs: if s['IsActive']: return True else: return False
def match_primary(table_name: str, primary_key: str, primary_key_val: str or int, index_name: str = None, query_index=False) -> Dict: """ Description: Use to make a query with primary key equal to value Link: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#DynamoDB.Table.query :param table_name: table to search through :param primary_key: the primary key of the table :param primary_key_val: the value of the primary key to search for :return: dict """ table = dynamodb.Table(table_name) if not query_index: response = table.query(TableName=table_name, KeyConditionExpression=conditions.Key( primary_key).eq(primary_key_val)) else: response = table.query(IndexName=index_name, KeyConditionExpression=conditions.Key( primary_key).eq(primary_key_val)) logger.debug({ "dynamodb_client": "query_matchPrimary_search_betweenSort", "success": True, "table_name": table_name, }) return response
def iter_resources(self, account_id, resource_type=None): expr = conditions.Key('AccountId').eq(account_id) if resource_type == "security-group": expr = expr & conditions.Key('ResourceId').between('sg-', 'vpc-') elif resource_type == "vpc": expr = expr & conditions.Key('ResourceId').begins_with('vpc-') results = self.table.scan(FilterExpression=expr) return results['Items']
def get_order(self, restaurant, date): response = self.table.query( KeyConditionExpression=conditions.Key('restaurant').eq(restaurant) & conditions.Key('date').eq(date)) if response['Items']: order = response['Items'][0] return order, "Success" else: return None, "No order."
def get_dish_price(self, restaurant, dishname): response = self.table.query( KeyConditionExpression=conditions.Key('restaurant').eq(restaurant) & conditions.Key('dishname').eq(dishname) ) if response['Items']: return response['Items'][0], "Success" else: return None, "No dish"
def get_books_by_author(author_name: str) -> typing.List[dict]: table = boto3.resource("dynamodb").Table(TABLE_NAME) response = table.query( KeyConditionExpression=conditions.Key("PK").eq(f"AUTHOR#{author_name}") \ & conditions.Key("SK").begins_with("ISBN") ) return response["Items"]
def get_book_by_isbn(isbn: str) -> dict: table = boto3.resource("dynamodb").Table(TABLE_NAME) response = table.query( KeyConditionExpression=conditions.Key("GSI1PK").eq(f"ISBN#{isbn}") \ & conditions.Key("GSI1SK").eq(f"ISBN#{isbn}"), IndexName="GSI1" ) return response["Items"][0]
def comment_delete(event, context): comments_table = DYNAMODB.Table('comments') deleted_comment = comments_table.delete_item( Key={'id': event['pathParameters']['id']}, ReturnValues='ALL_OLD').get('Attributes') if not deleted_comment: return redirect('/dev/') # Find child comments submission_comments = comments_table.scan( FilterExpression=conditions.Key('submission_id') .eq(deleted_comment['submission_id']), IndexName='CommentSubmissionIndex')['Items'] by_parent = {} for comment in submission_comments: by_parent.setdefault(comment.get('parent_id'), []).append(comment) queue = by_parent.get(deleted_comment['id'], []) with comments_table.batch_writer() as comments_batch: while queue: comment = queue.pop() if comment['id'] in by_parent: queue.extend(by_parent[comment['id']]) comments_batch.delete_item(Key={'id': comment['id']}) return redirect('/dev/submissions/{}' .format(deleted_comment['submission_id']))
def lambda_handler(event, context): encoded_image = event['base64Image'] decoded_image = base64.b64decode(encoded_image) threshold = 80 # user_id = 'dac' user_id = event['userId'] print(user_id) key_name = user_id dynamodb = boto3.resource('dynamodb', region_name=region, aws_access_key_id=aws_id, aws_secret_access_key=aws_key) table = dynamodb.Table(table_name) response = table.query( KeyConditionExpression=conditions.Key('user_id').eq(user_id)) target_name = response['Items'][0]['image_url'].split("/")[4] source_face, matches = compare_faces(decoded_image, bucket_name, target_name, threshold, region) print(matches[0]['Similarity']) if int(matches[0]['Similarity']) > 80: data = {'tokenId': 'AD78hdjjuUIIdkklppPPp00dauyd78', 'expiration': 900} return data else: data = {'tokenId': '', 'expiration': 0} return data
def submission_show(event, context): body = """<h1>{title} (via <a href="communities/{community}">{community}</a>)</h1> <p><a href="{url}">{url}</a></p> <div> <a class="btn btn-primary btn-sm" href="comments/new?submission_id={submission_id}">Comment</a> <a class="btn btn-danger btn-sm" data-confirm="Are you sure?" data-method="delete" href="submissions/{submission_id}">Delete Submission</a> </div> {comments} """ # NOQA submission_id = event['pathParameters']['id'] submission_table = DYNAMODB.Table('submissions') submission = submission_table.get_item(Key={'id': submission_id})['Item'] comments_table = DYNAMODB.Table('comments') comments = comments_table.scan( FilterExpression=conditions.Key('submission_id') .eq(submission_id), IndexName='CommentSubmissionIndex')['Items'] comments_body = "" if comments: comments_body = """<div> Comments:<br> {} </div> """.format('\n'.join([comment__render(comment) for comment in treeify(comments)])) return response(body.format( comments=comments_body, community=submission['community'], submission_id=submission_id, title=submission['title'], url=submission['url']))
def _pull_down_new_db_entries(self, pref): logger.log.info('pulling down new entries') this_node_id = pref.get_node_id() node_db = nodedb.NodeDB(self.app_data_folder, this_node_id) event_table_resource = self.event_table.get_table_resource() for node_id in self.node_table.get_all_nodes(): if node_id != this_node_id: most_recent_local = node_db.get_most_recent_entry(node_id) if most_recent_local: most_recent_local_mivui = most_recent_local['mivui'] else: most_recent_local_mivui = 0 logger.log.info('most_recent_local_mivui for : %s : %d' % (node_id, most_recent_local_mivui)) query_response = event_table_resource.query( KeyConditionExpression=conditions.Key('originator').eq(node_id) & conditions.Key('mivui').gt(most_recent_local_mivui) ) for q in query_response['Items']: logger.log.info('query_response : %s' % str(q)) mtime = q['mtime'] if mtime: mtime = maya.parse(mtime).datetime() size = q['size'] if size: size = int(size) logger.log.info('new_db_entry : %s' % str(q)) node_db.update(int(q['mivui']), q['originator'], int(q['event_type']), int(q['detection']), q['file_path'], q['src_path'], size, q['file_hash'], mtime, False)
def query_prefix(self, pk: PartitionKey, sk: PrefixSortKey, global_index: Optional[GlobalSecondaryIndex] = None, attributes: Optional[List[str]] = None, consistent: bool = False, limit: Optional[int] = None) -> List[ItemResult]: """Fetch a items from the table based on a sort key prefix. Doesn't support pagination. Args: pk: The partition key. sk: The sort key prefix. global_index: The global secondary index to query. Defaults to the primary index. attributes: The attributes to get. Defaults to `[self.primary_index.sort_key]` if no `global_index` is provided and `[global_index.sort_key]` if it is provided. consistent: Whether the read is strongly consistent or not. limit: The maximum number of items to fetch. Defaults to 1000. Returns: The requested items with the `PK` and `SK` prefixes stripped. Raises: dokklib_db.DatabaseError if there was an error querying DynamoDB. """ if global_index: pk_name = global_index.partition_key sk_name = global_index.sort_key else: pk_name = self.primary_index.partition_key sk_name = self.primary_index.sort_key if not attributes: attributes = [sk_name] key_condition = cond.Key(pk_name).eq(str(pk)) & \ cond.Key(sk_name).begins_with(str(sk)) query_arg = QueryArg(key_condition, global_index=global_index, attributes=attributes, consistent=consistent, limit=limit) return self._query(query_arg)
def get_device_id(self, intent_name: str) -> ObjectId: condition = conditions.Key("intent_id").eq(str(intent_name)) result = self.table.query(IndexName="by_intent_id", KeyConditionExpression=condition) if result["ResponseMetadata"]["HTTPStatusCode"] not in range(200, 300): raise AlexaRepositoryError( "error occurred when retrieving device_id") return ObjectId(result["Items"][0]["device_id"])
def get_user(self, userid): response = self.table.query( KeyConditionExpression=conditions.Key('userid').eq(userid)) if response['Items']: user = response['Items'][0] return user else: return None
def community_delete(event, context): community = event['pathParameters']['name'] DYNAMODB.Table('communities').delete_item(Key={'title': community}) comments_table = DYNAMODB.Table('comments') submissions_table = DYNAMODB.Table('submissions') with submissions_table.batch_writer() as submissions_batch: with comments_table.batch_writer() as comments_batch: for submission in submissions_table.scan( FilterExpression=conditions.Key('community').eq(community), IndexName='SubmissionCommunityIndex')['Items']: submissions_batch.delete_item(Key={'id': submission['id']}) for comment in comments_table.scan( FilterExpression=conditions.Key('submission_id') .eq(submission['id']), IndexName='CommentSubmissionIndex')['Items']: comments_batch.delete_item(Key={'id': comment['id']}) return redirect('/dev/')
def get_all_author_information(author_name: str) -> typing.List[dict]: table = boto3.resource("dynamodb").Table(TABLE_NAME) response = table.query( KeyConditionExpression=conditions.Key("PK").eq(f"AUTHOR#{author_name}") ) return response["Items"]
def find_location(self, restaurant): response = self.table.query( KeyConditionExpression=conditions.Key('userid').eq(restaurant) ) if response['Items']: user = response['Items'][0] return user else: return None
def get_user_order(self, userid): response = self.user_table.query( KeyConditionExpression=conditions.Key('user').eq(userid)) result = [] for user_order in response['Items']: order, message = self.get_order(user_order['restaurant'], user_order['date']) if order: result.append(order) return result
def get_dialog(self, intent_name: str, iot_err: int = 0, locale: str = "es-ES") -> Dialog: condition = conditions.Key("intent_id").eq( intent_name) & conditions.Key("iot_err").eq(iot_err) result = self.table.query(IndexName="by_intent_id_and_iot_err", KeyConditionExpression=condition) if result["ResponseMetadata"]["HTTPStatusCode"] not in range(200, 300): raise AlexaRepositoryError( "error occurred when retrieving dialog details") if len(result["Items"]) > 1: for item in result["Items"]: if item["locale"] == locale: return self._hydrate_record(item) return self._hydrate_record(result["Items"][0])
def submission_delete(event, context): submission_id = event['pathParameters']['id'] DYNAMODB.Table('submissions').delete_item(Key={'id': submission_id}) comments_table = DYNAMODB.Table('comments') with comments_table.batch_writer() as batch: for item in comments_table.scan( FilterExpression=conditions.Key('submission_id') .eq(submission_id), IndexName='CommentSubmissionIndex')['Items']: batch.delete_item(Key={'id': item['id']}) return redirect('/dev/')
def add_dish(self, restaurant, dishname, price): response = self.table.query( KeyConditionExpression=conditions.Key('restaurant').eq(restaurant) & conditions.Key('dishname').eq(dishname) ) if response['Items']: return False, restaurant + " " + dishname + " already exist." # print("[" + price + "]") response = self.table.put_item( Item={ 'restaurant': restaurant, 'dishname': dishname, 'price': price } ) if response: return True, "Success" else: return False, "Insert fail"
def position_exists(self, position: int) -> Optional[ObjectId]: condition = conditions.Key("position").eq(position) result = self.table.query(IndexName="by_position", KeyConditionExpression=condition) if result["ResponseMetadata"]["HTTPStatusCode"] not in range(200, 300): raise RepositoryError( "error occurred when retrieving device details") if result["Items"]: return ObjectId(result["Items"][0]["device_id"]) return None
def get(self, device_id: ObjectId) -> Device: condition = conditions.Key("device_id").eq(str(device_id)) result = self.table.query(KeyConditionExpression=condition) if result["ResponseMetadata"]["HTTPStatusCode"] not in range(200, 300): raise RepositoryError( "error occurred when retrieving device details") if not result["Count"]: raise RecordNotFound(f"Device with id {device_id} was not found") return self._hydrate_device(result["Items"][0])
def get_user(self, userid): response = self.table.query( KeyConditionExpression=conditions.Key('userid').eq(userid)) if response['Items']: user = response['Items'][0] user['salt'] = int(user['salt']) user['sweet'] = int(user['sweet']) user['sour'] = int(user['sour']) user['spicy'] = int(user['spicy']) return user else: return None
def get(self, query: dict) -> dict: try: response = self.table.query(IndexName=query['index'], KeyConditionExpression=conditions.Key( query['key']).eq(query['value'])) except exceptions.ClientError as error: print( f'Error when getting Dynamo Item using GSI on Table {self.dynamo_table}', error) else: return response['Items']
def get_dish(self, restaurant): response = self.table.query( KeyConditionExpression=conditions.Key('restaurant').eq(restaurant) ) dishes = [] if response['Items']: for i in response['Items']: dishes.append([i['dishname'], str(i['price'])]) return dishes else: # print(response) # todo what to do if no dishes? return []
def match_primary_between_sort(table_name, primary_key, primary_key_val, sort_key, sort_key_val_low, sort_key_val_high) -> Dict: """ Description: Use to make a query with primary key equal to value and sort key in between specific values Link: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#DynamoDB.Table.query :param table_name: table to search through :param primary_key: the primary key of the table :param primary_key_val: the value of the primary key to search for :param sort_key: the sort key of the table :param sort_key_val_low: the low end of the search range :param sort_key_val_high: the high end of the search range :return: dict """ try: table = dynamodb.Table(table_name) response = table.query( TableName=table_name, KeyConditionExpression=conditions.Key(primary_key).eq( primary_key_val) & conditions.Key(sort_key).between(sort_key_val_low, sort_key_val_high), ) logger.debug({ "dynamodb_client": "query_matchPrimary_search_betweenSort", "success": True, "table_name": table_name, }) return response except ClientError as e: err_message = { "dynamodb_client": "query_matchPrimary_search_betweenSort", "success": False, "msg": str(e.args[0]), } logger.error(err_message) raise Exception(err_message)
def make_key_conditions(list_of_keys_dicts): """ Key: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/customizations/dynamodb.html#boto3.dynamodb.conditions.Key Create a ke expressions concatenated string to be used in dynamodb query. :param list_of_keys_dicts: List of MAX TWO dicts, first entry is primary key, second is sort key (key link) -> example_entry: {'key':<key>, 'value':<value>, 'operator':<operator>} If value requires range, use a tuple for values (<HIGH_VALUE>, <LOW_VALUE>) :return: concatenated key condition """ key_conditions: Any = None first = True for key_dict in list_of_keys_dicts: if first: key_conditions = _add_condition(conditions.Key(key_dict['key']), key_dict['operator'], key_dict['value']) first = False else: key_conditions = key_conditions & _add_condition( conditions.Key(key_dict['key']), key_dict['operator'], key_dict['value']) return key_conditions
def community_show(event, context): body = """<h1>{community}</h1> {listing} <a class="btn btn-primary" href="submissions/new?community={community}">New Submission</a> <a class="btn btn-danger" data-confirm="Are you sure?" rel="nofollow" data-method="delete" href="communities/{community}">Delete Community</a> """ # NOQA community = event['pathParameters']['name'] table = DYNAMODB.Table('submissions') items = table.scan(FilterExpression=conditions.Key('community') .eq(community), IndexName='SubmissionCommunityIndex')['Items'] return response(body.format(community=community, listing=listing(reversed(items))))
def listing_row(submission): comments_table = DYNAMODB.Table('comments') results = comments_table.scan( FilterExpression=conditions.Key('submission_id') .eq(submission['id']), IndexName='CommentSubmissionIndex') comment_count = results['Count'] if comment_count == 1: comments = '1 comment' elif 'LastEvaluatedKey' in results: comments = '{}+ comments'.format(comment_count) else: comments = '{} comments'.format(comment_count) row = """<tr> <td><a href="{url}">{title}</a></td> <td>{url}</td> <td><a href="communities/{community}">{community}</a></td> <td><a class="btn btn-primary btn-sm" href="submissions/{id}">{comments}</td> </tr> """ # NOQA return row.format(comments=comments, **submission)