def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
*args:
**kwargs:
Returns:
The `FrameworkQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(self.skip_(skip))
if limit != 0:
self.query.append(self.limit_(limit))
return self.query
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int,
user: UserModel = None, permission: AccessControlPermission = None, *args, **kwargs) -> \
Union[Query, Pipeline]:
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if user and permission:
pass # TODO: ACLs
if limit == 0:
results_query = [self.skip_(limit)]
else:
results_query = [self.skip_(skip), self.limit_(limit)]
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(self.facet_({
'meta': [self.count_('total')],
'results': results_query
}))
return self.query
def count(
self,
filter: Union[List[dict], dict],
user: UserModel = None,
permission: AccessControlPermission = None
) -> Union[Query, Pipeline]:
"""
Count the number of documents in the stages
Args:
filter: filter requirement
user: request user
permission: acl permission
Returns:
Query with count stages.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if user and permission:
self.query += (AccessControlQueryBuilder().build(
group_id=PublicID(user.group_id), permission=permission))
self.query.append(self.count_('total'))
return self.query
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
*args:
**kwargs:
Returns:
The `FrameworkQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if limit == 0:
results_query = [self.skip_(limit)]
else:
results_query = [self.skip_(skip), self.limit_(limit)]
# TODO: Remove nasty quick hack
if sort.startswith('fields'):
sort_value = sort[7:]
self.query.append({"$addFields": {
"order": {
"$filter": {
"input": "$fields",
"as": "fields",
"cond": {"$eq": ["$$fields.name", sort_value]}
}
}
}})
self.query.append({'$sort': {'order': order}})
else:
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(self.facet_({
'meta': [self.count_('total')],
'results': results_query
}))
return self.query
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int,
user: UserModel = None, permission: AccessControlPermission = None, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
user: request user
permission: AccessControlPermission
*args:
**kwargs:
Returns:
The `LogQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if user and permission:
self.query += (LookedAccessControlQueryBuilder().build(
group_id=PublicID(user.group_id), permission=permission))
if limit == 0:
results_query = [self.skip_(limit)]
else:
results_query = [self.skip_(skip), self.limit_(limit)]
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(
self.facet_({
'meta': [self.count_('total')],
'results': results_query
}))
return self.query
def count(self, filter: Union[List[dict], dict], *args, **kwargs) -> Union[Query, Pipeline]:
"""
Count the number of documents in the stages
Args:
filter: filter requirement
Returns:
Query with count stages.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
self.query.append(self.count_('total'))
return self.query
class AccountManagerQueryBuilder(Builder):
"""Query/Pipeline builder class for the user management managers"""
def __init__(self):
"""Init a query or a pipeline to None"""
self.query: Union[Query, Pipeline] = Pipeline([])
super(AccountManagerQueryBuilder, self).__init__()
def __len__(self):
"""Get the length of the query"""
return len(self.query)
def clear(self):
"""`Delete` the query content"""
self.query = None
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
*args:
**kwargs:
Returns:
The `AccountManagerQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if limit == 0:
results_query = [self.skip_(limit)]
else:
results_query = [self.skip_(skip), self.limit_(limit)]
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(
self.facet_({
'meta': [self.count_('total')],
'results': results_query
}))
return self.query
def __init__(self):
"""Init a query or a pipeline to None"""
self.query: Union[Query, Pipeline] = Pipeline([])
super(FrameworkQueryBuilder, self).__init__()
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int,
user: UserModel = None, permission: AccessControlPermission = None, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
user: request user
permission: AccessControlPermission
*args:
**kwargs:
Returns:
The `FrameworkQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
loading_dep_preset = [
self.lookup_(_from='framework.types',
_local='type_id',
_foreign='public_id',
_as='type'),
self.unwind_({'path': '$type'}),
self.match_({'type': {
'$ne': None
}}),
self.lookup_(_from='management.users',
_local='author_id',
_foreign='public_id',
_as='author'),
self.unwind_({
'path': '$author',
'preserveNullAndEmptyArrays': True
}),
self.lookup_(_from='management.users',
_local='editor_id',
_foreign='public_id',
_as='editor'),
self.unwind_({
'path': '$editor',
'preserveNullAndEmptyArrays': True
}),
]
self.query = Pipeline(loading_dep_preset)
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if user and permission:
self.query += (AccessControlQueryBuilder().build(
group_id=PublicID(user.group_id), permission=permission))
if limit == 0:
results_query = [self.skip_(limit)]
else:
results_query = [self.skip_(skip), self.limit_(limit)]
# TODO: Remove nasty quick hack
if sort.startswith('fields'):
sort_value = sort[7:]
self.query.append({
'$addFields': {
'order': {
'$filter': {
'input': '$fields',
'as': 'fields',
'cond': {
'$eq': ['$$fields.name', sort_value]
}
}
}
}
})
self.query.append({'$sort': {'order': order}})
else:
self.query.append(self.sort_(sort=sort, order=order))
self.query += results_query
return self.query
class ManagerQueryBuilder(Builder):
"""Query/Pipeline builder class for the managers"""
def __init__(self):
"""Init a query or a pipeline to None"""
self.query: Union[Query, Pipeline] = Pipeline([])
super(ManagerQueryBuilder, self).__init__()
def __len__(self):
"""Get the length of the query"""
return len(self.query)
def clear(self):
"""`Delete` the query content"""
self.query = None
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
*args:
**kwargs:
Returns:
The `FrameworkQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(self.skip_(skip))
if limit != 0:
self.query.append(self.limit_(limit))
return self.query
def count(self, filter: Union[List[dict], dict], *args, **kwargs) -> Union[Query, Pipeline]:
"""
Count the number of documents in the stages
Args:
filter: filter requirement
Returns:
Query with count stages.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
self.query.append(self.count_('total'))
return self.query
def build(self, filter: Union[List[dict], dict], limit: int, skip: int, sort: str, order: int,
user: UserModel = None, permission: AccessControlPermission = None, *args, **kwargs) -> \
Union[Query, Pipeline]:
"""
Converts the parameters from the call to a mongodb aggregation pipeline
Args:
filter: dict or list of dict query/queries which the elements have to match.
limit: max number of documents to return.
skip: number of documents to skip first.
sort: sort field
order: sort order
user: request user
permission: AccessControlPermission
*args:
**kwargs:
Returns:
The `FrameworkQueryBuilder` query pipeline with the parameter contents.
"""
self.clear()
self.query = Pipeline([])
if isinstance(filter, dict):
self.query.append(self.match_(filter))
elif isinstance(filter, list):
for pipe in filter:
self.query.append(pipe)
if user and permission:
self.query += (AccessControlQueryBuilder().build(
group_id=user.group_id, permission=permission))
if limit == 0:
results_query = [self.skip_(limit)]
else:
results_query = [self.skip_(skip), self.limit_(limit)]
# TODO: Remove nasty quick hack
if sort.startswith('fields'):
sort_value = sort[7:]
self.query.append({
'$addFields': {
'order': {
'$filter': {
'input': '$fields',
'as': 'fields',
'cond': {
'$eq': ['$$fields.name', sort_value]
}
}
}
}
})
self.query.append({'$sort': {'order': order}})
else:
self.query.append(self.sort_(sort=sort, order=order))
self.query.append(
self.facet_({
'meta': [self.count_('total')],
'results': results_query
}))
return self.query
def __init__(self):
"""Init a query or a pipeline to None"""
self.query: Union[Query, Pipeline] = Pipeline([])
super(AccountManagerQueryBuilder, self).__init__()
