def update(self, other):
try:
# NOTE(kgriffs): If it is a mapping type, it should
# implement keys().
names = other.keys()
except AttributeError:
# NOTE(kgriffs): Not a mapping type, so assume it is an
# iterable of 2-item iterables. But we need to make it
# re-iterable if it is a generator, for when we pass
# it on to the parent's update().
other = list(other)
names = [n for n, __ in other]
for n in names:
self._validate(n)
UserDict.update(self, other)
def update(self, *args, **kwargs):
UserDict.update(self, *args, **kwargs)
self.save()
class Transform(SimpleItem):
"""A transform is an external method with
additional configuration information
"""
meta_type = 'Transform'
meta_types = all_meta_types = ()
manage_options = ((
{
'label': 'Configure',
'action': 'manage_main'
},
{
'label': 'Reload',
'action': 'manage_reloadTransform'
},
) + SimpleItem.manage_options)
manage_main = PageTemplateFile('configureTransform', _www)
manage_reloadTransform = PageTemplateFile('reloadTransform', _www)
tr_widgets = PageTemplateFile('tr_widgets', _www)
security = ClassSecurityInfo()
__allow_access_to_unprotected_subobjects__ = 1
def __init__(self, id, module, transform=None):
self.id = id
self.module = module
# DM 2004-09-09: 'Transform' instances are stored as
# part of a module level configuration structure
# Therefore, they must not contain persistent objects
self._config = UserDict()
self._config.__allow_access_to_unprotected_subobjects__ = 1
self._config_metadata = UserDict()
self._tr_init(1, transform)
def __setstate__(self, state):
""" __setstate__ is called whenever the instance is loaded
from the ZODB, like when Zope is restarted.
We should reload the wrapped transform at this time
"""
Transform.inheritedAttribute('__setstate__')(self, state)
self._tr_init()
def _tr_init(self, set_conf=0, transform=None):
""" initialize the zope transform by loading the wrapped transform """
__traceback_info__ = (self.module, )
if transform is None:
transform = self._load_transform()
else:
self._v_transform = transform
# check this is a valid transform
if not hasattr(transform, '__class__'):
raise TransformException(
'Invalid transform : transform is not a class')
if not ITransform.providedBy(transform):
raise TransformException(
'Invalid transform : ITransform is not implemented by %s' %
transform.__class__)
if not hasattr(transform, 'inputs'):
raise TransformException(
'Invalid transform : missing required "inputs" attribute')
if not hasattr(transform, 'output'):
raise TransformException(
'Invalid transform : missing required "output" attribute')
# manage configuration
if set_conf and hasattr(transform, 'config'):
conf = dict(transform.config)
self._config.update(conf)
make_config_persistent(self._config)
if hasattr(transform, 'config_metadata'):
conf = dict(transform.config_metadata)
self._config_metadata.update(conf)
make_config_persistent(self._config_metadata)
transform.config = dict(self._config)
make_config_nonpersistent(transform.config)
transform.config_metadata = dict(self._config_metadata)
make_config_nonpersistent(transform.config_metadata)
self.inputs = transform.inputs
self.output = transform.output
self.output_encoding = getattr(transform, 'output_encoding', None)
return transform
def _load_transform(self):
try:
return self._v_transform
except AttributeError:
pass
try:
m = import_from_name(self.module)
except ImportError as err:
transform = BrokenTransform(self.id, self.module, err)
msg = "Cannot register transform %s (ImportError), using BrokenTransform: Error\n %s" % (
self.id, err)
self.title = 'BROKEN'
log(msg, severity=ERROR)
return transform
if not hasattr(m, 'register'):
msg = 'Invalid transform module %s: no register function defined' % self.module
raise TransformException(msg)
try:
transform = m.register()
except Exception as err:
transform = BrokenTransform(self.id, self.module, err)
msg = "Cannot register transform %s, using BrokenTransform: Error\n %s" % (
self.id, err)
self.title = 'BROKEN'
log(msg, severity=ERROR)
else:
self.title = ''
self._v_transform = transform
return transform
security.declarePrivate('manage_beforeDelete')
def manage_beforeDelete(self, item, container):
SimpleItem.manage_beforeDelete(self, item, container)
if self is item:
# unregister self from catalog on deletion
# While building business template, transform tool will be
# copied and this transform will be removed from copied one
# so that this must not use getToolByName to retrive the tool.
tr_tool = self.aq_parent
tr_tool._unmapTransform(self)
security.declarePublic('get_documentation')
def get_documentation(self):
""" return transform documentation """
return self._load_transform().__doc__
security.declarePrivate('convert')
def convert(self, *args, **kwargs):
""" return apply the transform and return the result """
return self._load_transform().convert(*args, **kwargs)
security.declarePublic('name')
def name(self):
"""return the name of the transform instance"""
return self.id
security.declareProtected(ManagePortal, 'get_parameters')
def get_parameters(self):
""" get transform's parameters names """
return sorted(self._load_transform().config.keys())
security.declareProtected(ManagePortal, 'get_parameter_value')
def get_parameter_value(self, key):
""" get value of a transform's parameter """
value = self._config[key]
type = self.get_parameter_infos(key)[0]
if type == 'dict':
result = {}
for key, val in value.items():
result[key] = val
elif type == 'list':
result = list(value)
else:
result = value
return result
security.declareProtected(ManagePortal, 'get_parameter_infos')
def get_parameter_infos(self, key):
""" get informations about a parameter
return a tuple (type, label, description [, type specific data])
where type in (string, int, list, dict)
label and description are two string describing the field
there may be some additional elements specific to the type :
(key label, value label) for the dict type
"""
try:
return tuple(self._config_metadata[key])
except KeyError:
return 'string', '', ''
security.declareProtected(ManagePortal, 'set_parameters')
def set_parameters(self, REQUEST=None, **kwargs):
""" set transform's parameters """
if not kwargs:
kwargs = REQUEST.form
self.preprocess_param(kwargs)
for param, value in kwargs.items():
try:
self.get_parameter_value(param)
except KeyError:
log('Warning: ignored parameter %r' % param)
continue
meta = self.get_parameter_infos(param)
self._config[param] = VALIDATORS[meta[0]](value)
tr_tool = getToolByName(self, 'portal_transforms')
# need to remap transform if necessary (i.e. configurable inputs / output)
if 'inputs' in kwargs or 'output' in kwargs:
tr_tool._unmapTransform(self)
transform = self._load_transform()
self.inputs = kwargs.get('inputs', transform.inputs)
self.output = kwargs.get('output', transform.output)
tr_tool._mapTransform(self)
# track output encoding
if 'output_encoding' in kwargs:
self.output_encoding = kwargs['output_encoding']
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(tr_tool.absolute_url() +
'/manage_main')
security.declareProtected(ManagePortal, 'reload')
def reload(self):
""" reload the module where the transformation class is defined """
log('Reloading transform %s' % self.module)
if not self.module.startswith('erp5.'):
reload(import_from_name(self.module))
self._tr_init()
security.declarePrivate('preprocess_param')
def preprocess_param(self, kwargs):
""" preprocess param fetched from an http post to handle optional dictionary
"""
for param in self.get_parameters():
if self.get_parameter_infos(param)[0] == 'dict':
try:
keys = kwargs[param + '_key']
del kwargs[param + '_key']
except:
keys = ()
try:
values = kwargs[param + '_value']
del kwargs[param + '_value']
except:
values = ()
kwargs[param] = dict = {}
for key, value in zip(keys, values):
key = key.strip()
if key:
value = value.strip()
if value:
dict[key] = value
def update(self, *args, **kwargs):
if six.PY3:
UserDict.update(self, *args, **kwargs)
else:
self._update_py2(*args, **kwargs)
