async def __call__(self):
if self.key is _marker:
# No option to write the root of registry
return ErrorResponse('InvalidRequest', 'Needs the registry key')
data = await self.request.json()
if 'value' in data:
value = data['value']
else:
value = data
assert '.' in self.key, 'Registry key must be dotted.iface.name.fieldname' # noqa
iface, name = self.key.rsplit('.', 1)
iface = resolve(iface)
field = iface[name]
try:
new_value = getMultiAdapter((value, field), IJSONToValue)
except ComponentLookupError:
return ErrorResponse('DeserializationError',
'Cannot deserialize type {}'.format(
str(self.field)),
status=501)
try:
self.request.site_settings[self.key] = new_value
except DeserializationError as e:
return ErrorResponse('DeserializationError',
str(e),
exc=e,
status=400)
return Response(response={}, status=204)
async def __call__(self):
data = await self.request.json()
if '@type' not in data and data['@type'] != 'Site':
return ErrorResponse('NotAllowed',
'can not create this type %s' % data['@type'],
status=401)
if 'title' not in data and not data['title']:
return ErrorResponse('NotAllowed', 'We need a title', status=401)
if 'id' not in data:
return ErrorResponse('NotAllowed', 'We need an id', status=401)
if 'description' not in data:
data['description'] = ''
if data['id'] in self.context:
# Already exist
return ErrorResponse('NotAllowed', 'Duplicate id', status=401)
site = create_content('Site',
id=data['id'],
title=data['title'],
description=data['description'])
# Special case we don't want the parent pointer
site.__name__ = data['id']
self.context[data['id']] = site
site.install()
self.request._site_id = site.__name__
user = get_authenticated_user_id(self.request)
# Local Roles assign owner as the creator user
roleperm = IPrincipalRoleManager(site)
roleperm.assignRoleToPrincipal('plone.Owner', user)
await notify(ObjectFinallyCreatedEvent(site))
# await notify(ObjectAddedEvent(site, self.context, site.__name__))
resp = {'@type': 'Site', 'id': data['id'], 'title': data['title']}
headers = {'Location': self.request.path + data['id']}
return Response(response=resp, headers=headers)
async def uninstall(context, request):
data = await request.json()
id_to_install = data.get('id', None)
if id_to_install not in app_settings['available_addons']:
return ErrorResponse('RequiredParam',
_("Property 'id' is required to be valid"))
registry = request.site_settings
config = registry.for_interface(IAddons)
if id_to_install not in config.enabled:
return ErrorResponse('Duplicate', _("Addon not installed"))
handler = app_settings['available_addons'][id_to_install]['handler']
if asyncio.iscoroutinefunction(handler.install):
await handler.uninstall(request)
else:
handler.uninstall(request)
config.enabled -= {id_to_install}
async def __call__(self):
data = await self.get_data()
behaviors = data.get('@behaviors', None)
for behavior in behaviors or ():
self.context.add_behavior(behavior)
deserializer = queryMultiAdapter((self.context, self.request),
IResourceDeserializeFromJson)
if deserializer is None:
return ErrorResponse('DeserializationError',
'Cannot deserialize type {}'.format(
self.context.portal_type),
status=501)
try:
await deserializer(data)
except DeserializationError as e:
return ErrorResponse('DeserializationError', str(e), status=400)
await notify(ObjectFinallyModifiedEvent(self.context))
return Response(response={}, status=204)
async def __call__(self):
""" data input : { 'interface': 'INTERFACE' }"""
if not hasattr(self.request, 'site_settings'):
return ErrorResponse('BadRequest', _("Not in a site request"))
data = await self.request.json()
interface = data.get('interface', None)
initial_values = data.get('initial_values', {})
if interface is None:
return ErrorResponse('InvalidRequest', 'Non existent Interface')
registry = self.request.site_settings
iObject = import_class(interface)
registry.register_interface(iObject)
config = registry.for_interface(iObject)
# Initialize values
# If its defined on the zope.schema default will not be overwritten
# you will need to PATCH
for key, field in getFields(iObject).items():
if key in initial_values and not getattr(config, key, False):
# We don't have a value
setattr(config, key, initial_values[key])
return Response(response={}, status=201)
async def initialize(self, app=None):
# loop
self.app = app
while True:
got_obj = False
try:
priority, view = await self._queue.get()
got_obj = True
if view.request.conn.transaction_manager is None:
# Connection was closed
# Open DB
db = view.request.application[view.request._db_id]
if SHARED_CONNECTION:
view.request.conn = db.conn
else:
# Create a new conection
view.request.conn = db.open()
view.context = view.request.conn.get(view.context._p_oid)
txn = view.request.conn.transaction_manager.begin(view.request)
try:
view_result = await view()
if isinstance(view_result, ErrorResponse):
await sync(view.request)(txn.abort)
elif isinstance(view_result, UnauthorizedResponse):
await sync(view.request)(txn.abort)
else:
await sync(view.request)(txn.commit)
except Unauthorized:
await sync(view.request)(txn.abort)
view_result = UnauthorizedResponse(
_('Not authorized to render operation'))
except Exception as e:
logger.error("Exception on writing execution", exc_info=e)
await sync(view.request)(txn.abort)
view_result = ErrorResponse(
'ServiceError', _('Error on execution of operation'))
except KeyboardInterrupt or MemoryError or SystemExit or asyncio.CancelledError:
self._exceptions = True
raise
except Exception as e: # noqa
self._exceptions = True
logger.error('Worker call failed', exc_info=e)
finally:
if got_obj:
self._queue.task_done()
def generate_error_response(e, request, error, status=400):
# We may need to check the roles of the users to show the real error
eid = uuid.uuid4().hex
message = _('Error on execution of view') + ' ' + eid
user = get_authenticated_user_id(request)
extra = {
'r': _url(request),
'u': user
}
logger.error(
message,
exc_info=e,
extra=extra)
return ErrorResponse(
error,
message,
status
)
async def __call__(self):
"""To create a content."""
data = await self.get_data()
type_ = data.get('@type', None)
id_ = data.get('id', None)
behaviors = data.get('@behaviors', None)
if not type_:
return ErrorResponse('RequiredParam',
_("Property '@type' is required"))
# Generate a temporary id if the id is not given
if not id_:
new_id = None
else:
new_id = id_
user = get_authenticated_user_id(self.request)
# Create object
try:
obj = create_content_in_container(self.context,
type_,
new_id,
id=new_id,
creators=(user, ),
contributors=(user, ))
except PreconditionFailed as e:
return ErrorResponse('PreconditionFailed', str(e), status=412)
except ConflictIdOnContainer as e:
return ErrorResponse('ConflictId', str(e), status=409)
except ValueError as e:
return ErrorResponse('CreatingObject', str(e), status=400)
for behavior in behaviors or ():
obj.add_behavior(behavior)
# Update fields
deserializer = queryMultiAdapter((obj, self.request),
IResourceDeserializeFromJson)
if deserializer is None:
return ErrorResponse('DeserializationError',
'Cannot deserialize type {}'.format(
obj.portal_type),
status=501)
try:
await deserializer(data, validate_all=True)
except DeserializationError as e:
return ErrorResponse('DeserializationError',
str(e),
exc=e,
status=400)
# Local Roles assign owner as the creator user
roleperm = IPrincipalRoleManager(obj)
roleperm.assignRoleToPrincipal('plone.Owner', user)
await notify(ObjectFinallyCreatedEvent(obj))
absolute_url = queryMultiAdapter((obj, self.request), IAbsoluteURL)
headers = {
'Access-Control-Expose-Headers': 'Location',
'Location': absolute_url()
}
serializer = queryMultiAdapter((obj, self.request),
IResourceSerializeToJson)
return Response(response=serializer(), headers=headers, status=201)
async def __call__(self):
return ErrorResponse('NotImplemented',
'Function not implemented',
status=501)