async def test_parse_metadata(dummy_guillotina):
from guillotina.contrib.catalog.pg import PGSearchUtility
util = PGSearchUtility()
with mocks.MockTransaction():
content = test_utils.create_content(Container)
query = parse_query(content, {"_metadata": "foobar"})
result = util.load_meatdata(query, {"foobar": "foobar", "blah": "blah"})
assert result == {"foobar": "foobar"}
query = parse_query(content, {"_metadata_not": "foobar"})
result = util.load_meatdata(query, {"foobar": "foobar", "blah": "blah"})
assert result == {"blah": "blah"}
async def unrestrictedSearch(self, context: IBaseObject,
query: typing.Any):
"""
Search query without restriction, uses parser to transform query
"""
parsed_query = parse_query(context, query, self)
return await self._query(context, parsed_query, True) # type: ignore
async def test_build_pg_query(dummy_guillotina):
from guillotina.contrib.catalog.pg import PGSearchUtility
util = PGSearchUtility()
with mocks.MockTransaction():
content = test_utils.create_content(Container)
query = parse_query(content, {'uuid': content.uuid}, util)
assert content.uuid == query['wheres_arguments'][0]
assert "json->'uuid'" in query['wheres'][0]
async def query_aggregation(self, context: IBaseObject, query: typing.Any):
'''
Raw search query, uses parser to transform query
'''
parsed_query = parse_query(context, query, self)
container = find_container(context)
if container is not None:
return await self.aggregation(container, parsed_query)
raise ContainerNotFound()
async def search(self, context: IBaseObject, query: typing.Any):
"""
Search query, uses parser to transform query
"""
parsed_query = parse_query(context, query, self)
container = find_container(context)
if container is not None:
return await self._query(container, parsed_query) # type: ignore
raise ContainerNotFound()
async def search_get(context, request):
query = request.query.copy()
search = get_search_utility(query)
if search is None:
return {'@id': request.url, 'items': [], 'items_total': 0}
parsed_query = parse_query(context, query, search)
container = find_container(context)
result = await search.search(container, parsed_query)
return {
'@id': request.url,
'items': result['member'],
'items_total': result['items_count'],
'batching': {
'from': parsed_query['_from'] or 0,
'size': parsed_query['size']
}
}
def set_search(self, search):
if self.container is None:
raise KeyError('Container needed to be defined')
self.search = search
self.parsed_query = parse_query(self.context, self.search,
self.utility)
async def search(self, context: IBaseObject, query: typing.Any):
"""
Search query, uses parser to transform query
"""
parsed_query = parse_query(context, query, self)
return await self._query(context, parsed_query) # type: ignore
async def query_aggregation(self, context: IBaseObject, query: typing.Any):
"""
Raw search query, uses parser to transform query
"""
parsed_query = parse_query(context, query, self)
return await self.aggregation(context, parsed_query)
