def _validate_vocabulary_name(self, schema, field, vocabulary_name):
if not vocabulary_name:
return True
if (
vocabulary_name != getattr(field, 'vocabulary', None) and
vocabulary_name != getattr(field, 'vocabularyName', None)
):
# Determine the widget to check for vocabulary there
widgets = mergedTaggedValueDict(schema, WIDGETS_KEY)
widget = widgets.get(field.getName())
if widget:
if isinstance(widget, six.string_types):
widget = resolveDottedName(widget)
if widget:
widget = widget(field, self._request)
else:
# default widget
widget = queryMultiAdapter(
(field, self._request),
IFieldWidget
)
if widget:
widget.update()
if getattr(widget, 'vocabulary', None) != vocabulary_name:
return False
return True
def __call__(self, field, request):
__traceback_info__ = (
'{0}, processing:\n'
'- field "{1}"\n'
'- widget: {2}\n'
'- params: {3}\n'.format(
self.__class__.__name__,
field.__name__,
repr(self.widget_factory),
self.params
)
)
if isinstance(self.widget_factory, six.string_types):
__traceback_info__ += '- resolving dotted name\n'
self.widget_factory = resolveDottedName(self.widget_factory)
if self.widget_factory is None:
# use default widget factory for this field type
__traceback_info__ += '- using default widget factory\n'
widget = getMultiAdapter((field, request), IFieldWidget)
elif IWidget.implementedBy(self.widget_factory):
__traceback_info__ += '- calling factory, then wrapping with ' \
'FieldWidget\n'
widget = FieldWidget(field, self.widget_factory(request))
elif IFieldWidget.implementedBy(self.widget_factory):
__traceback_info__ += '- calling factory\n'
widget = self.widget_factory(field, request)
for k, v in self.params.items():
setattr(widget, k, v)
return widget
def _validate_vocabulary_name(self, schema, field, vocabulary_name):
if not vocabulary_name:
return True
if (
vocabulary_name != getattr(field, 'vocabulary', None) and
vocabulary_name != getattr(field, 'vocabularyName', None)
):
# Determine the widget to check for vocabulary there
widgets = mergedTaggedValueDict(schema, WIDGETS_KEY)
widget = widgets.get(field.getName())
if widget:
if isinstance(widget, six.string_types):
widget = resolveDottedName(widget)
if widget:
widget = widget(field, self._request)
else:
# default widget
widget = queryMultiAdapter(
(field, self._request),
IFieldWidget
)
if widget:
widget.update()
if getattr(widget, 'vocabulary', None) != vocabulary_name:
return False
return True
def _add(self, schema, key, name, value, expected=None):
if expected is not None:
obj = resolveDottedName(value)
if not expected.implementedBy(obj):
raise ValueError("%s not implemented by %s"
% (expected.__identifier__, value))
tagged_value = schema.queryTaggedValue(key, {})
tagged_value[name] = value
schema.setTaggedValue(key, tagged_value)
def updateWidgets(self):
widgets = mergedTaggedValueDict(self.schema, WIDGETS_KEY)
if self.field in widgets:
factory = widgets[self.field]
if self.fields[self.field].widgetFactory.get(
self.mode, None) is None:
if isinstance(factory, basestring):
factory = resolveDottedName(factory)
self.fields[self.field].widgetFactory = factory
DisplayForm.updateWidgets(self)
def _add_validator(self, field, value):
validator = resolveDottedName(value)
if not IValidator.implementedBy(validator):
raise ValueError(
"z3c.form.interfaces.IValidator not implemented by %s."
% value)
provideAdapter(validator,
(None, None, None, getSpecification(field), None),
IValidator,
)
def _add_validator(self, field, value):
validator = resolveDottedName(value)
if not IValidator.implementedBy(validator):
msg = 'z3c.form.interfaces.IValidator not implemented by {0}.'
raise ValueError(msg.format(value))
provideAdapter(
validator,
(None, None, None, getSpecification(field), None),
IValidator,
)
def read(self, fieldNode, schema, field):
name = field.__name__
widgetAttr = fieldNode.get(ns('widget', self.namespace))
mode = fieldNode.get(ns('mode', self.namespace))
omitted = fieldNode.get(ns('omitted', self.namespace))
before = fieldNode.get(ns('before', self.namespace))
after = fieldNode.get(ns('after', self.namespace))
validator = fieldNode.get(ns('validator', self.namespace))
if mode:
self._add_interface_values(schema, MODES_KEY, name, mode)
if omitted:
self._add_interface_values(schema, OMITTED_KEY, name, omitted)
if before:
self._add_order(schema, name, 'before', before)
if after:
self._add_order(schema, name, 'after', after)
if validator:
self._add_validator(field, validator)
widgetNode = fieldNode.find(ns('widget', self.namespace))
widget = None
if widgetNode is not None: # form:widget element
widgetFactory = widgetNode.get('type')
if widgetFactory is not None:
# resolve immediately so we don't have to each time
# form is rendered
widgetFactory = resolveDottedName(widgetFactory)
widget = ParameterizedWidget(widgetFactory)
widgetHandler = widget.getExportImportHandler(field)
widgetHandler.read(widgetNode, widget.params)
elif widgetAttr is not None: # BBB for old form:widget attributes
obj = resolveDottedName(widgetAttr)
if not IFieldWidget.implementedBy(obj):
raise ValueError(
'IFieldWidget not implemented by {0}'.format(obj)
)
widget = widgetAttr
if widget is not None:
self._add(schema, WIDGETS_KEY, name, widget)
def read(self, fieldNode, schema, field):
name = field.__name__
widgetAttr = fieldNode.get(ns('widget', self.namespace))
mode = fieldNode.get(ns('mode', self.namespace))
omitted = fieldNode.get(ns('omitted', self.namespace))
before = fieldNode.get(ns('before', self.namespace))
after = fieldNode.get(ns('after', self.namespace))
validator = fieldNode.get(ns('validator', self.namespace))
if mode:
self._add_interface_values(schema, MODES_KEY, name, mode)
if omitted:
self._add_interface_values(schema, OMITTED_KEY, name, omitted)
if before:
self._add_order(schema, name, 'before', before)
if after:
self._add_order(schema, name, 'after', after)
if validator:
self._add_validator(field, validator)
widgetNode = fieldNode.find(ns('widget', self.namespace))
widget = None
if widgetNode is not None: # form:widget element
widgetFactory = widgetNode.get('type')
if widgetFactory is not None:
# resolve immediately so we don't have to each time
# form is rendered
widgetFactory = resolveDottedName(widgetFactory)
widget = ParameterizedWidget(widgetFactory)
widgetHandler = widget.getExportImportHandler(field)
widgetHandler.read(widgetNode, widget.params)
elif widgetAttr is not None: # BBB for old form:widget attributes
obj = resolveDottedName(widgetAttr)
if not IFieldWidget.implementedBy(obj):
raise ValueError(
'IFieldWidget not implemented by {0}'.format(obj))
widget = widgetAttr
if widget is not None:
self._add(schema, WIDGETS_KEY, name, widget)
def _add_interface_values(self, schema, key, name, values):
tagged_value = schema.queryTaggedValue(key, [])
values = values.split(" ")
for value in values:
if ":" in value:
(interface_dotted_name, value) = value.split(":")
interface = resolveDottedName(interface_dotted_name)
if not isinstance(interface, InterfaceClass):
raise ValueError("%s not an Interface." % interface_dotted_name)
else:
interface = Interface
tagged_value.append((interface, name, value))
schema.setTaggedValue(key, tagged_value)
def __call__(self, field, request):
if isinstance(self.widget_factory, basestring):
self.widget_factory = resolveDottedName(self.widget_factory)
if self.widget_factory is None:
# use default widget factory for this field type
widget = getMultiAdapter((field, request), IFieldWidget)
elif IWidget.implementedBy(self.widget_factory):
widget = FieldWidget(field, self.widget_factory(request))
elif IFieldWidget.implementedBy(self.widget_factory):
widget = self.widget_factory(field, request)
for k, v in self.params.items():
setattr(widget, k, v)
return widget
def __call__(self, field, request):
if isinstance(self.widget_factory, basestring):
self.widget_factory = resolveDottedName(self.widget_factory)
if self.widget_factory is None:
# use default widget factory for this field type
widget = getMultiAdapter((field, request), IFieldWidget)
elif IWidget.implementedBy(self.widget_factory):
widget = FieldWidget(field, self.widget_factory(request))
elif IFieldWidget.implementedBy(self.widget_factory):
widget = self.widget_factory(field, request)
for k, v in self.params.items():
setattr(widget, k, v)
return widget
def _add_interface_values(self, schema, key, name, values):
tagged_value = schema.queryTaggedValue(key, [])
values = values.split(' ')
for value in values:
if ':' in value:
(interface_dotted_name, value) = value.split(':')
interface = resolveDottedName(interface_dotted_name)
if not isinstance(interface, InterfaceClass):
raise ValueError(
"%s not an Interface." % interface_dotted_name)
else:
interface = Interface
tagged_value.append((interface, name, value))
schema.setTaggedValue(key, tagged_value)
def validate(self, field_name, vocabulary_name=None):
context = self.context
checker = getSecurityManager().checkPermission
schemata = self._get_schemata()
for schema in schemata:
if field_name in schema:
# If a vocabulary name was specified and it does not
# match the vocabulary name for the field or widget,
# fail.
field = schema[field_name]
if vocabulary_name and (
vocabulary_name != getattr(field, 'vocabulary', None)
and vocabulary_name != getattr(field, 'vocabularyName',
None)):
# Determine the widget to check for vocabulary there
widgets = mergedTaggedValueDict(schema, WIDGETS_KEY)
widget = widgets.get(field_name)
if widget:
widget = (isinstance(widget, basestring)
and resolveDottedName(widget) or widget)
widget = widget and widget(field, self._request)
else:
widget = queryMultiAdapter((field, self._request),
IFieldWidget)
if widget:
widget.update()
if getattr(widget, 'vocabulary', None) != vocabulary_name:
return False
# Create mapping of all schema permissions
permissions = mergedTaggedValueDict(schema,
WRITE_PERMISSIONS_KEY)
permission_name = permissions.get(field_name, None)
if permission_name is not None:
permission = queryUtility(IPermission,
name=permission_name)
if permission:
return checker(permission.title, context)
# If the field is in the schema, but no permission is
# specified, fall back to the default edit permission
return checker(self.DEFAULT_PERMISSION, context)
else:
raise AttributeError('No such field: {0}'.format(field_name))
def validate(self, field_name, vocabulary_name=None):
context = self.context
checker = getSecurityManager().checkPermission
schemata = self._get_schemata()
for schema in schemata:
if field_name in schema:
# If a vocabulary name was specified and it does not
# match the vocabulary name for the field or widget,
# fail.
field = schema[field_name]
if vocabulary_name and (
vocabulary_name != getattr(field, 'vocabulary', None) and
vocabulary_name != getattr(field, 'vocabularyName', None)):
# Determine the widget to check for vocabulary there
widgets = mergedTaggedValueDict(schema, WIDGETS_KEY)
widget = widgets.get(field_name)
if widget:
widget = (isinstance(widget, basestring) and
resolveDottedName(widget) or widget)
widget = widget and widget(field, self._request)
else:
widget = queryMultiAdapter((field, self._request),
IFieldWidget)
if widget:
widget.update()
if getattr(widget, 'vocabulary', None) != vocabulary_name:
return False
# Create mapping of all schema permissions
permissions = mergedTaggedValueDict(schema,
WRITE_PERMISSIONS_KEY)
permission_name = permissions.get(field_name, None)
if permission_name is not None:
permission = queryUtility(IPermission,
name=permission_name)
if permission:
return checker(permission.title, context)
# If the field is in the schema, but no permission is
# specified, fall back to the default edit permission
return checker(self.DEFAULT_PERMISSION, context)
else:
raise AttributeError('No such field: {0}'.format(field_name))
def __call__(self, field, request):
__traceback_info__ = ('{0}, processing:\n'
'- field "{1}"\n'
'- widget: {2}\n'
'- params: {3}\n'.format(
self.__class__.__name__, field.__name__,
repr(self.widget_factory), self.params))
if isinstance(self.widget_factory, six.string_types):
__traceback_info__ += '- resolving dotted name\n'
self.widget_factory = resolveDottedName(self.widget_factory)
if self.widget_factory is None:
# use default widget factory for this field type
__traceback_info__ += '- using default widget factory\n'
widget = getMultiAdapter((field, request), IFieldWidget)
elif IWidget.implementedBy(self.widget_factory):
__traceback_info__ += '- calling factory, then wrapping with ' \
'FieldWidget\n'
widget = FieldWidget(field, self.widget_factory(request))
elif IFieldWidget.implementedBy(self.widget_factory):
__traceback_info__ += '- calling factory\n'
widget = self.widget_factory(field, request)
for k, v in self.params.items():
setattr(widget, k, v)
return widget
