async def get_schema(self, schema, context, result, behavior):
read_permissions = merged_tagged_value_dict(schema,
read_permission.key)
schema_serial = {}
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name)):
continue
if behavior:
# omit/include for behaviors need full name
dotted_name = schema.__identifier__ + '.' + name
else:
dotted_name = name
if (dotted_name in self.omit
or (len(self.include) > 0 and
(dotted_name not in self.include
and schema.__identifier__ not in self.include))):
# make sure the fields aren't filtered
continue
value = await self.serialize_field(context, field)
if not behavior:
result[name] = value
else:
schema_serial[name] = value
if behavior and len(schema_serial) > 0:
result[schema.__identifier__] = schema_serial
async def __call__(self):
""" data input : { 'interface': 'INTERFACE' }"""
if not hasattr(self.request, 'container_settings'):
return ErrorResponse('BadRequest', _("Not in a container request"))
await lock_object(self.request.container_settings)
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.container_settings
iObject = import_class(interface)
registry.register_interface(iObject)
config = registry.for_interface(iObject)
# Initialize values
# If its defined on the guillotina.schema default will not be overwritten
# you will need to PATCH
for key, field in getFields(iObject).items():
if key in initial_values and getattr(config, key,
_marker) == _marker:
# We don't have a value
config[key] = initial_values[key]
return Response(response={}, status=201)
async def __call__(self):
result = {'type': self.field_type}
for schema in implementedBy(self.field.__class__).flattened():
self.field_attributes.update(getFields(schema))
for attribute_name in sorted(self.field_attributes.keys()):
attribute_field = self.field_attributes[attribute_name]
if attribute_name in self.filtered_attributes:
continue
element_name = attribute_field.__name__
attribute_field = attribute_field.bind(self.field)
force = (element_name in self.forced_fields)
value = attribute_field.get(self.field)
# For 'default', 'missing_value' etc, we want to validate against
# the imported field type itself, not the field type of the
# attribute
if element_name in self.field_type_attributes or \
element_name in self.non_validated_field_type_attributes:
attribute_field = self.field
text = None
if isinstance(value, bytes):
text = value.decode('utf-8')
elif isinstance(value, str):
text = value
elif IField.providedBy(value):
serializer = getMultiAdapter((value, self.field, self.request),
ISchemaFieldSerializeToJson)
text = await serializer()
elif value is not None and (force
or value != self.field.missing_value):
text = IValueToJson(value)
# handle i18n
# if isinstance(value, Message):
# child.set(ns('domain', I18N_NAMESPACE), value.domain)
# if not value.default:
# child.set(ns('translate', I18N_NAMESPACE), '')
# else:
# child.set(ns('translate', I18N_NAMESPACE), child.text)
# child.text = converter.toUnicode(value.default)
if text:
if attribute_name == 'value_type':
attribute_name = 'items'
result[attribute_name] = text
if result['type'] == 'object':
if IJSONField.providedBy(self.field):
result['properties'] = self.field.json_schema
else:
schema_serializer = getMultiAdapter(
(self.field.schema, self.request), ISchemaSerializeToJson)
result['properties'] = await schema_serializer()
return result
async def get_schema(self, schema, context, result, behavior):
read_permissions = merged_tagged_value_dict(schema,
read_permission.key)
schema_serial = {}
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name)):
continue
serializer = queryMultiAdapter((field, context, self.request),
IResourceFieldSerializer)
value = await serializer()
if not behavior:
result[name] = value
else:
schema_serial[name] = value
if behavior:
result[schema.__identifier__] = schema_serial
async def set_schema(self,
schema,
obj,
data,
errors,
validate_all=False,
behavior=False):
write_permissions = merged_tagged_value_dict(schema,
write_permission.key)
for name, field in getFields(schema).items():
if field.readonly:
continue
if behavior:
found = False
if schema.__identifier__ in data:
sdata = data[schema.__identifier__]
data_value = sdata[name] if name in sdata else None
found = True if name in sdata else False
else:
data_value = data[name] if name in data else None
found = True if name in data else False
f = schema.get(name)
if found:
if not self.check_permission(write_permissions.get(name)):
continue
# Deserialize to field value
deserializer = queryMultiAdapter((f, obj, self.request),
IResourceFieldDeserializer)
if deserializer is None:
continue
try:
value = await apply_coroutine(deserializer, data_value)
except ValueError as e:
errors.append({
'message': e.message,
'field': name,
'error': e
})
except ValidationError as e:
errors.append({
'message': e.doc(),
'field': name,
'error': e
})
except Invalid as e:
errors.append({
'message': e.args[0],
'field': name,
'error': e
})
else:
# record object changes for potential future conflict resolution
try:
await apply_coroutine(field.set, obj, value)
except Exception:
logger.warning(
'Error setting data on field, falling back to setattr',
exc_info=True)
setattr(obj, name, value)
else:
if f.required and not hasattr(obj, name):
errors.append({
'message': 'Required parameter',
'field': name,
'error': ValueError('Required parameter')
})
if validate_all:
invariant_errors = []
try:
schema.validateInvariants(object, invariant_errors)
except Invalid:
# Just collect errors
pass
validation = [(None, e) for e in invariant_errors]
if len(validation):
for e in validation:
errors.append({
'message': e[1].doc(),
'field': e[0],
'error': e
})
def _callFUT(self, schema):
from guillotina.schema import getFields
return getFields(schema)
async def set_schema(self,
schema,
obj,
data,
errors,
validate_all=False,
behavior=False):
write_permissions = merged_tagged_value_dict(schema,
write_permission.key)
for name, field in getFields(schema).items():
if field.readonly:
continue
if behavior:
data_value = data[schema.__identifier__][name] if name in data[
schema.__identifier__] else None # noqa
found = True if name in data[schema.__identifier__] else False
else:
data_value = data[name] if name in data else None
found = True if name in data else False
f = schema.get(name)
if found:
if not self.check_permission(write_permissions.get(name)):
continue
# Deserialize to field value
deserializer = queryMultiAdapter((f, obj, self.request),
IResourceFieldDeserializer)
if deserializer is None:
continue
try:
value = deserializer(data_value)
except ValueError as e:
errors.append({
'message': e.message,
'field': name,
'error': e
})
except ValidationError as e:
errors.append({
'message': e.doc(),
'field': name,
'error': e
})
except Invalid as e:
errors.append({
'message': e.args[0],
'field': name,
'error': e
})
else:
try:
field.set(obj, value)
except: # noqa
setattr(obj, name, value)
else:
if f.required and not hasattr(obj, name):
errors.append({
'message': 'Required parameter',
'field': name,
'error': ValueError('Required parameter')
})
if validate_all:
invariant_errors = []
try:
schema.validateInvariants(object, invariant_errors)
except Invalid:
# Just collect errors
pass
validation = [(None, e) for e in invariant_errors]
if len(validation):
for e in validation:
errors.append({
'message': e[1].doc(),
'field': e[0],
'error': e
})
