async def test_get_content_depth(container_requester):
async with container_requester as requester:
response, status = await requester(
"POST", "/db/guillotina/", data=json.dumps({"@type": "Item", "title": "Item1", "id": "item1"})
)
assert status == 201
root = await get_root(db=requester.db)
tm = requester.db.get_transaction_manager()
txn = await tm.begin()
container = await root.async_get("guillotina")
obj = await container.async_get("item1")
assert utils.get_content_depth(container) == 1
assert utils.get_content_depth(obj) == 2
await tm.abort(txn=txn)
async def get_path_query(self, resource, response=noop_response):
if isinstance(resource, str):
path = resource
depth = path.count('/') + 1
else:
path = get_content_path(resource)
depth = get_content_depth(resource)
depth += 1
path_query = {
'query': {
'bool': {
'must': [
]
}
}
}
if path != '/':
path_query['query']['bool']['must'].append({
'term':
{'path': path}
})
path_query['query']['bool']['must'].append({
'range':
{'depth': {'gte': depth}}
})
return path_query
async def get_path_query(self, resource, index_name=None, response=noop_response):
if isinstance(resource, str):
path = resource
depth = path.count('/') + 1
else:
path = get_content_path(resource)
depth = get_content_depth(resource)
depth += 1
response.write(b'Removing all children of %s' % path.encode('utf-8'))
request = None
if index_name is None:
request = get_current_request()
index_name = await self.get_index_name(request.container)
path_query = {
'query': {
'bool': {
'must': [
]
}
}
}
if path != '/':
path_query['query']['bool']['must'].append({
'term':
{'path': path}
})
path_query['query']['bool']['must'].append({
'range':
{'depth': {'gte': depth}}
})
return path_query
async def test_get_content_depth(container_requester):
async with container_requester as requester:
response, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert utils.get_content_depth(container) == 1
assert utils.get_content_depth(obj) == 2
await request._tm.abort(txn=txn)
async def test_get_content_depth(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert utils.get_content_depth(container) == 1
assert utils.get_content_depth(obj) == 2
await request._tm.abort(txn=txn)
def __call__(self):
""" access_users and access_roles """
return {
'path': get_content_path(self.content),
'depth': get_content_depth(self.content),
'parent_uuid': getattr(
getattr(self.content, '__parent__', None), 'uuid', None),
'access_users': get_principals_with_access_content(self.content),
'access_roles': get_roles_with_access_content(self.content),
'type_name': self.content.type_name
}
def __call__(self):
""" access_users and access_roles """
return {
"path": get_content_path(self.content),
"depth": get_content_depth(self.content),
"parent_uuid": getattr(getattr(self.content, "__parent__", None), "uuid", None),
"access_users": get_principals_with_access_content(self.content),
"access_roles": get_roles_with_access_content(self.content),
"type_name": self.content.type_name,
"tid": self.content.__serial__,
"modification_date": json_compatible(self.content.modification_date),
}
async def __call__(self):
search = get_search_utility()
container = find_container(self.context)
depth = get_content_depth(container)
max_depth = None
if "expand.navigation.depth" in self.request.query:
max_depth = str(
int(self.request.query["expand.navigation.depth"]) + depth)
depth_query = {"depth__gte": depth, "depth__lte": max_depth}
else:
depth_query = {"depth": depth}
depth_query["hidden_navigation"] = False
result = await search.search(
container,
{
**{
"_sort_asc": "position_in_parent",
"_size": 100
},
**depth_query
},
)
pending_dict = {}
for brain in result["items"]:
brain_serialization = {
"title": brain.get("title"),
"@id": brain.get("@id"),
"@name": brain.get("uuid"),
"description": "",
}
pending_dict.setdefault(brain.get("parent_uuid"),
[]).append(brain_serialization)
parent_uuid = container.uuid
if parent_uuid not in pending_dict:
final_list = []
else:
final_list = pending_dict[parent_uuid]
if max_depth is not None:
recursive_fill(final_list, pending_dict)
return {"@id": self.request.url, "items": final_list}
async def get_path_query(self, resource, response=noop_response):
if isinstance(resource, str):
path = resource
depth = path.count("/") + 1
else:
path = get_content_path(resource)
depth = get_content_depth(resource)
depth += 1
path_query = {"query": {"bool": {"must": []}}}
if path != "/":
path_query["query"]["bool"]["must"].append(
{"term": {
"path": path
}})
path_query["query"]["bool"]["must"].append(
{"range": {
"depth": {
"gte": depth
}
}})
return path_query
def get_depth(ob):
return get_content_depth(ob)
def get_depth(ob):
return get_content_depth(ob)
def __call__(self, params: typing.Dict) -> BasicParsedQueryInfo:
# bbb
if "SearchableText" in params:
value = params.pop("SearchableText")
oring = {}
for index_name, idx_data in iter_indexes():
if idx_data["type"] in ("text", "searchabletext"):
oring["{}__in".format(index_name)] = value
params["searchabletext__or"] = oring
if params.get("sort_on") == "getObjPositionInParent":
params["_sort_asc"] = "position_in_parent"
del params["sort_on"]
if "b_size" in params:
if "b_start" in params:
params["_from"] = params.pop("b_start")
params["_size"] = params.pop("b_size")
if "path.depth" in params:
params["depth"] = params.pop("path.depth")
if "portal_type" in params:
params["type_name"] = params.pop("portal_type")
if "_fullobjects" in params:
fullobjects = True
else:
fullobjects = False
_from = 0
size = 20
sort_field = None
sort_dir = "ASC"
# normalize depth
found = False
for param in [k for k in params.keys()]:
if param == "depth" or param.startswith("depth__"):
found = True
params[param] = str(
int(params[param]) + get_content_depth(self.context))
if not found:
# default to a depth so we don't show container
params["depth__gte"] = str(1 + get_content_depth(self.context))
# From
if "_from" in params:
try:
_from = int(params.pop("_from"))
except ValueError:
_from = 0
# Sort
if "_sort_asc" in params:
sort_field = params.pop("_sort_asc")
sort_dir = "ASC"
elif "_sort_des" in params:
sort_field = params.pop("_sort_des")
sort_dir = "DESC"
# Path specific use case
if "path__starts" in params:
path = params.pop("path__starts")
path = "/" + path.strip("/")
else:
path = get_content_path(self.context)
params["path__starts"] = path
if "_size" in params:
try:
size = min(int(params.pop("_size")), 50)
except ValueError:
pass
# Metadata
metadata = None
if params.get("_metadata") or params.get("metadata_fields"):
fields: str = typing.cast(
str,
params.get("_metadata") or params.get("metadata_fields"))
if "_all" not in fields:
metadata = to_list(fields)
params.pop("_metadata", None)
params.pop("metadata_fields", None)
excluded_metadata = None
if params.get("_metadata_not"):
excluded_metadata = to_list(params.pop("_metadata_not"))
return {
"_from": _from,
"size": size,
"sort_on": sort_field,
"sort_dir": sort_dir,
"metadata": metadata,
"fullobjects": fullobjects,
"excluded_metadata": excluded_metadata,
"params": params,
}
async def __call__(self):
search = query_utility(ICatalogUtility)
context = self.request.container
path = get_content_path(context)
depth = get_content_depth(context) + 1
max_depth = None
if 'expand.navigation.depth' in self.request.rel_url.query:
max_depth = str(
int(self.request.rel_url.query['expand.navigation.depth']) +
depth)
musts = [{
'range': {
'depth': {
'gte': depth
}
}
}, {
'range': {
'depth': {
'lte': max_depth
}
}
}]
else:
musts = [{'term': {'depth': depth}}]
query = {
'_source': {
'includes': [
'title', '_id', 'depth', 'parent_uuid', '@absolute_url',
'type_name', 'path'
],
},
'query': {
'bool': {
'must': musts,
}
},
'sort': [{
'position_in_parent': 'desc'
}],
}
call_params = {
'container': self.request.container,
'path': path,
'query': query,
'size': 100
}
result = await search.get_by_path(**call_params)
pending_dict = {}
for brain in result['member']:
brain_serialization = {
'title': brain['title'],
'@id': brain['@absolute_url']
}
pending_dict.setdefault(brain['parent_uuid'],
[]).append(brain_serialization)
parent_uuid = context.uuid
if parent_uuid not in pending_dict:
final_list = []
else:
final_list = pending_dict[parent_uuid]
if max_depth is not None:
recursive_fill(final_list, pending_dict)
return {"@id": self.request.url.human_repr(), "items": final_list}
def __call__(self, params: typing.Dict) -> BasicParsedQueryInfo:
# bbb
if 'SearchableText' in params:
value = params.pop('SearchableText')
oring = {}
for index_name, idx_data in iter_indexes():
if idx_data['type'] in ('text', 'searchabletext'):
oring['{}__in'.format(index_name)] = value
params['searchabletext__or'] = oring
if params.get('sort_on') == 'getObjPositionInParent':
params['_sort_asc'] = 'position_in_parent'
del params['sort_on']
if 'b_size' in params:
if 'b_start' in params:
params['_from'] = params.pop('b_start')
params['_size'] = params.pop('b_size')
if 'path.depth' in params:
params['depth'] = params.pop('path.depth')
if 'portal_type' in params:
params['type_name'] = params.pop('portal_type')
_from = 0
size = 20
sort_field = None
sort_dir = 'ASC'
# normalize depth
found = False
for param in [k for k in params.keys()]:
if param == 'depth' or param.startswith('depth__'):
found = True
params[param] = str(
int(params[param]) + get_content_depth(self.context))
if not found:
# default to a depth so we don't show container
params['depth__gte'] = str(1 + get_content_depth(self.context))
# From
if '_from' in params:
try:
_from = int(params.pop('_from'))
except ValueError:
_from = 0
# Sort
if '_sort_asc' in params:
sort_field = params.pop('_sort_asc')
sort_dir = 'ASC'
elif '_sort_des' in params:
sort_field = params.pop('_sort_des')
sort_dir = 'DESC'
# Path specific use case
if 'path__starts' in params:
path = params.pop('path__starts')
path = '/' + path.strip('/')
else:
path = get_content_path(self.context)
params['path__starts'] = path
if '_size' in params:
try:
size = min(int(params.pop('_size')), 50)
except ValueError:
pass
# Metadata
metadata = None
if (params.get('_metadata') or params.get('metadata_fields')):
fields: str = typing.cast(
str,
params.get('_metadata') or params.get('metadata_fields'))
if '_all' not in fields:
metadata = to_list(fields)
params.pop('_metadata', None)
params.pop('metadata_fields', None)
excluded_metadata = None
if params.get('_metadata_not'):
excluded_metadata = to_list(params.pop('_metadata_not'))
return {
'_from': _from,
'size': size,
'sort_on': sort_field,
'sort_dir': sort_dir,
'metadata': metadata,
'excluded_metadata': excluded_metadata,
'params': params
}
def __call__(self, get_params=None, container=None):
if get_params is None:
get_params = dict(self.request.rel_url.query)
if container is None:
container = self.request.container
# Fullobject
if '_fullobject' in get_params:
full_objects = True
del get_params['_fullobject']
else:
full_objects = False
query = {
'_source': {
'includes': [],
'excludes': []
},
'query': {
'bool': {
'must': [],
'must_not': []
}
},
'sort': []
}
bbb_parser(get_params)
if 'depth' in get_params:
get_params['depth'] = str(
int(get_params['depth']) + get_content_depth(self.context))
if '_aggregations' in get_params:
query['aggregations'] = {}
for agg in convert(get_params['_aggregations']):
if agg == 'portal_type':
# XXX: Compatibility with plone?
agg = 'type_name'
query['aggregations'][agg] = {
'terms': {
'field': agg,
'size': MAX_AGGS
}
}
del get_params['_aggregations']
# Metadata
if '_metadata' in get_params:
query['_sources']['includes'] = convert(get_params['_metadata'])
del get_params['_metadata']
if '_metadata_not' in get_params:
query['_sources']['excludes'] = convert(
get_params['_metadata_not'])
del get_params['_metadata_not']
# From
if '_from' in get_params:
query['from'] = get_params['_from']
del get_params['_from']
# Sort
if '_sort_asc' in get_params:
for field in convert(get_params['_sort_asc']):
query['sort'].append({field: 'asc'})
del get_params['_sort_asc']
if '_sort_des' in get_params:
for field in convert(get_params['_sort_des']):
query['sort'].append({field: 'desc'})
del get_params['_sort_des']
query['sort'].append({'_id': 'desc'})
# Path specific use case
if 'path__starts' in get_params:
path = get_params['path__starts']
path = '/' + '/'.join(convert(path))
del get_params['path__starts']
else:
path = get_content_path(self.context)
# TODO _aggregations
call_params = {'container': container, 'path': path, 'query': query}
if '_size' in get_params:
call_params['size'] = get_params['_size']
del get_params['_size']
for field, value in get_params.items():
process_field(field, convert(value), query)
return call_params, full_objects
