async def prepare(self):
type_id = self.request.matchdict["type_id"]
self.value = queryUtility(IResourceFactory, name=type_id)
if self.value is None:
raise HTTPNotFound(
content={"reason": f"Could not find type {type_id}", "type": type_id}
)
async def add_object(obj, event):
uid = getattr(obj, 'uuid', None)
if uid is None:
return
type_name = getattr(obj, 'type_name', None)
if type_name is None or IContainer.providedBy(obj):
return
fut = get_future()
if fut is None:
return
search = queryUtility(ICatalogUtility)
if search:
if IObjectModifiedEvent.providedBy(event):
indexes = []
if event.payload and len(event.payload) > 0:
# get a list of potential indexes
for field_name in event.payload.keys():
if '.' in field_name:
for behavior_field_name in event.payload[field_name].keys():
indexes.append(behavior_field_name)
else:
indexes.append(field_name)
fut.update[uid] = await search.get_data(obj, indexes)
else:
fut.index[uid] = await search.get_data(obj)
async def __call__(self):
util = queryUtility(IQueueUtility)
if util:
await util.add(
CatalogReindex(self.context, self.request,
self._security_reindex))
return {}
async def search_post(context, request):
q = await request.json()
search = queryUtility(ICatalogUtility)
if search is None:
return {'items_count': 0, 'member': []}
return await search.query(context, q)
async def prepare(self):
type_id = self.request.matchdict['type_id']
self.value = queryUtility(IResourceFactory, name=type_id)
if self.value is None:
raise HTTPNotFound(content={
'reason': f'Could not find type {type_id}',
'type': type_id
})
async def __call__(self, json_value):
if self.request.resource:
fti = queryUtility(
IFactory, name=self.request.resource.type_name)
schema_summary = getMultiAdapter(
(fti, self.request), IResourceSerializeToJson)
json_value['schema'] = await schema_summary()
return json_value
async def search_get(context, request):
q = request.GET.get('q')
search = queryUtility(ICatalogUtility)
if search is None:
return {'items_count': 0, 'member': []}
return await search.get_by_path(site=request.site,
path=get_content_path(context),
query=q)
async def __call__(self, trns):
if not trns:
return
# Commits are run in sync thread so there is no asyncloop
search = queryUtility(ICatalogUtility)
if search:
await search.remove(self.site, self.remove)
await search.index(self.site, self.index)
self.index = {}
self.remove = []
def check_permission(self, permission_name):
if permission_name is None:
return True
if permission_name not in self.permission_cache:
permission = queryUtility(IPermission, name=permission_name)
if permission is None:
self.permission_cache[permission_name] = True
else:
security = IInteraction(self.request)
self.permission_cache[permission_name] = bool(
security.check_permission(permission.title, self.context))
return self.permission_cache[permission_name]
async def add_object(obj, event):
uid = getattr(obj, 'uuid', None)
if uid is None:
return
type_name = getattr(obj, 'type_name', None)
if type_name is None or IContainer.providedBy(obj):
return
hook = get_hook()
if hook is None:
return
search = queryUtility(ICatalogUtility)
if search:
hook.index[uid] = await search.get_data(obj)
async def test_get_data_uses_indexes_param(dummy_request):
util = queryUtility(ICatalogUtility)
request = dummy_request # noqa
container = await create_content(
'Container',
id='guillotina',
title='Guillotina')
container.__name__ = 'guillotina'
ob = await create_content('Item', id='foobar')
data = await util.get_data(ob, indexes=['title'])
assert len(data) == 3 # uuid and type_name always returned
data = await util.get_data(ob)
assert len(data) > 7
def add_object(obj, event):
uid = getattr(obj, 'uuid', None)
if uid is None:
return
portal_type = getattr(obj, 'portal_type', None)
if portal_type is None or ISite.providedBy(obj):
return
hook = get_hook()
if hook is None:
return
search = queryUtility(ICatalogUtility)
if search:
hook.index[uid] = search.get_data(obj)
async def create_content_in_container(container,
type_,
id_,
request=None,
**kw):
"""Utility to create a content.
This method is the one to use to create content.
id_ can be None
"""
factory = get_cached_factory(type_)
if factory.add_permission:
if factory.add_permission in PERMISSIONS_CACHE:
permission = PERMISSIONS_CACHE[factory.add_permission]
else:
permission = queryUtility(IPermission, name=factory.add_permission)
PERMISSIONS_CACHE[factory.add_permission] = permission
if request is None:
request = get_current_request()
if permission is not None and \
not IInteraction(request).check_permission(permission.id, container):
raise NoPermissionToAdd(str(container), type_)
constrains = IConstrainTypes(container, None)
if constrains is not None:
if not constrains.is_type_allowed(type_):
raise NotAllowedContentType(str(container), type_)
# We create the object with at least the ID
obj = factory(id=id_)
obj.__parent__ = container
obj.__name__ = obj.id
for key, value in kw.items():
setattr(obj, key, value)
if request is None or 'OVERWRITE' not in request.headers:
if await container.async_contains(obj.id):
raise ConflictIdOnContainer(str(container), obj.id)
obj.__new_marker__ = True
await notify(BeforeObjectAddedEvent(obj, container, id_))
await container.async_set(obj.id, obj)
return obj
def check_permission(self, permission_name):
if permission_name is None:
return True
if permission_name not in self.permission_cache:
permission = queryUtility(IPermission, name=permission_name)
if permission is None:
self.permission_cache[permission_name] = True
else:
try:
self.permission_cache[permission_name] = bool(
IInteraction(self.request).check_permission(
permission.id, self.context))
except NoInteraction:
# not authenticated
return False
return self.permission_cache[permission_name]
def get_future():
request = get_current_request()
try:
container = request.container
search = queryUtility(ICatalogUtility)
except (AttributeError, KeyError):
return
if not search:
return # no search configured
fut = request.get_future('indexer')
if fut is None:
fut = IndexFuture(container, request)
request.add_future('indexer', fut)
return fut
async def execute_actions(self, rules):
for rule in rules:
for action in rule['actions']:
action_type = action.get('action_type')
action_configuration = action.get('configuration')
action = queryUtility(IActionType, name=action_type)
if action is None:
logger.warn(f'Invalid configuration for action, skipping: '
f'{action_type}: {action_configuration}')
break
try:
action(self._object, self._request, self._event,
action_configuration)
except:
logger.warn(
'Error executing content rule action '
f'{action_type}: {action_configuration}',
exc_info=True)
async def __call__(self):
if self.request.view_error:
# there was an error executing this view, we do not want to execute
return
# Commits are run in sync thread so there is no asyncloop
search = queryUtility(ICatalogUtility)
if search:
if len(self.remove) > 0:
await search.remove(self.container, self.remove)
if len(self.index) > 0:
await search.index(self.container, self.index)
if len(self.update) > 0:
await search.update(self.container, self.update)
self.index = {}
self.update = {}
self.remove = []
async def get_matching_rules(self):
matched = []
for rule in self._rules:
if len(rule['conditions']) == 0:
matched.append(rule)
continue
for condition in rule['conditions']:
condition_type = condition.get('condition_type')
condition_configuration = condition.get('configuration')
condition = queryUtility(IConditionType, name=condition_type)
if condition is None:
logger.warn(
f'Invalid configuration for condition, skipping: '
f'{condition_type}: {condition_configuration}')
continue
if condition(self._object, self._request, self._event,
condition_configuration):
matched.append(rule)
break
return matched
def get_hook():
request = get_current_request()
try:
container = request.container
search = queryUtility(ICatalogUtility)
except (AttributeError, KeyError):
return
if not search:
return # no search configured
trns = get_transaction(request)
hook = None
for _hook in trns._after_commit:
if isinstance(_hook[0], CommitHook):
hook = _hook[0]
break
if hook is None:
hook = CommitHook(container, request)
trns.add_after_commit_hook(hook)
return hook
async def publish_traverse(self, traverse):
if len(traverse) == 1:
# we want have the field
name = traverse[0]
fti = queryUtility(IFactory, name=self.context.type_name)
schema = fti.schema
field = None
self.behavior = None
if name in schema:
field = schema[name]
else:
# TODO : We need to optimize and move to content.py iterSchema
for behavior_schema in fti.behaviors or ():
if name in behavior_schema:
field = behavior_schema[name]
self.behavior = behavior_schema(self.context)
break
for behavior_name in self.context.__behaviors__ or ():
behavior_schema = BEHAVIOR_CACHE[behavior_name]
if name in behavior_schema:
field = behavior_schema[name]
self.behavior = behavior_schema(self.context)
break
# Check that its a File Field
if field is None:
raise KeyError('No valid name')
self.field = field.bind(self.behavior)
else:
self.field = None
if (self.behavior is not None
and IAsyncBehavior.implementedBy(self.behavior.__class__)):
# providedBy not working here?
await self.behavior.load()
return self
async def initialize_catalog(site, event):
search = queryUtility(ICatalogUtility)
if search:
await search.initialize_catalog(site)
async def publish_traverse(self, traverse):
if len(traverse) == 1:
# we want have the key of the registry
self.value = queryUtility(IResourceFactory, name=traverse[0])
return self
async def initialize_catalog(container, event):
search = queryUtility(ICatalogUtility)
if search:
await search.initialize_catalog(container)
async def catalog_post(context, request):
search = queryUtility(ICatalogUtility)
await search.initialize_catalog(context)
return {}
async def catalog_delete(context, request):
search = queryUtility(ICatalogUtility)
await search.remove_catalog(context)
return {}
async def remove_catalog(container, event):
search = queryUtility(ICatalogUtility)
if search:
await search.remove_catalog(container)
async def __call__(self):
search = queryUtility(ICatalogUtility)
await search.reindex_all_content(self.context, self._security_reindex)
return {}
async def remove_catalog(site, event):
search = queryUtility(ICatalogUtility)
if search:
await search.remove_catalog(site)
async def test_registered_base_utility(dummy_request):
util = queryUtility(ICatalogUtility)
assert util is not None
async def __call__(self):
data = await self.request.json()
mailer = queryUtility(IMailer)
await mailer.send(**data)
return Response(content={'messages_sent': 1}, status=200)
