from types import ListType, TupleType, StringType
from warnings import warn
from Products.Archetypes.Storage import MetadataStorage
from Products.Archetypes.Layer import DefaultLayerContainer
from Products.Archetypes.interfaces.field import IField
from Products.Archetypes.interfaces.layer import ILayerContainer, \
ILayerRuntime, ILayer
from Products.Archetypes.interfaces.schema import ISchema, ISchemata, \
IManagedSchema
from Products.Archetypes.utils import OrderedDict, mapply, shasattr
from Products.Archetypes.mimetype_utils import getDefaultContentType
from Products.Archetypes.exceptions import SchemaException
from Products.Archetypes.exceptions import ReferenceException
from AccessControl import ClassSecurityInfo
from Acquisition import aq_base, Explicit
from ExtensionClass import Base
from App.class_init import InitializeClass
from Products.CMFCore import permissions
from Products.CMFCore.utils import getToolByName
from zope.interface import implements
__docformat__ = 'reStructuredText'
_marker = []
def getNames(schema):
"""Returns a list of all fieldnames in the given schema."""
return [f.getName() for f in schema.fields()]
def getSchemata(obj):
"""Returns an ordered dictionary, which maps all Schemata names to fields
that belong to the Schemata."""
schema = obj.Schema()
schemata = OrderedDict()
for f in schema.fields():
sub = schemata.get(f.schemata, WrappedSchemata(name=f.schemata))
sub.addField(f)
schemata[f.schemata] = sub.__of__(obj)
return schemata
class Schemata(Base):
"""Manage a list of fields by grouping them together.
Schematas are identified by their names.
"""
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
implements(ISchemata)
def __init__(self, name='default', fields=None):
"""Initialize Schemata and add optional fields."""
self.__name__ = name
self._names = []
self._fields = {}
if fields is not None:
if type(fields) not in [ListType, TupleType]:
fields = (fields, )
for field in fields:
self.addField(field)
security.declareProtected(permissions.View, 'getName')
def getName(self):
"""Returns the Schemata's name."""
return self.__name__
def __add__(self, other):
"""Returns a new Schemata object that contains all fields and layers
from ``self`` and ``other``.
"""
c = Schemata()
for field in self.fields():
c.addField(field)
for field in other.fields():
c.addField(field)
return c
security.declareProtected(permissions.View, 'copy')
def copy(self):
"""Returns a deep copy of this Schemata.
"""
c = Schemata()
for field in self.fields():
c.addField(field.copy())
return c
security.declareProtected(permissions.View, 'fields')
def fields(self):
"""Returns a list of my fields in order of their indices."""
return [self._fields[name] for name in self._names]
security.declareProtected(permissions.View, 'values')
values = fields
security.declareProtected(permissions.View, 'editableFields')
def editableFields(self, instance, visible_only=False):
"""Returns a list of editable fields for the given instance
"""
ret = []
portal = getToolByName(instance, 'portal_url').getPortalObject()
for field in self.fields():
if field.writeable(instance, debug=False) and \
(not visible_only or
field.widget.isVisible(instance, 'edit') != 'invisible') and \
field.widget.testCondition(instance.aq_parent, portal, instance):
ret.append(field)
return ret
security.declareProtected(permissions.View, 'viewableFields')
def viewableFields(self, instance):
"""Returns a list of viewable fields for the given instance
"""
return [field for field in self.fields()
if field.checkPermission('view', instance)]
security.declareProtected(permissions.View, 'widgets')
def widgets(self):
"""Returns a dictionary that contains a widget for
each field, using the field name as key."""
widgets = {}
for f in self.fields():
widgets[f.getName()] = f.widget
return widgets
security.declareProtected(permissions.View,
'filterFields')
def filterFields(self, *predicates, **values):
"""Returns a subset of self.fields(), containing only fields that
satisfy the given conditions.
You can either specify predicates or values or both. If you provide
both, all conditions must be satisfied.
For each ``predicate`` (positional argument), ``predicate(field)`` must
return 1 for a Field ``field`` to be returned as part of the result.
Each ``attr=val`` function argument defines an additional predicate:
A field must have the attribute ``attr`` and field.attr must be equal
to value ``val`` for it to be in the returned list.
"""
results = []
for field in self.fields(): # step through each of my fields
# predicate failed:
failed = [pred for pred in predicates if not pred(field)]
if failed: continue
# attribute missing:
missing_attrs = [attr for attr in values.keys() \
if not shasattr(field, attr)]
if missing_attrs: continue
# attribute value unequal:
diff_values = [attr for attr in values.keys() \
if getattr(field, attr) != values[attr]]
if diff_values: continue
results.append(field)
return results
def __setitem__(self, name, field):
assert name == field.getName()
self.addField(field)
security.declareProtected(permissions.ModifyPortalContent,
'addField')
def addField(self, field):
"""Adds a given field to my dictionary of fields."""
field = aq_base(field)
self._validateOnAdd(field)
name = field.getName()
if name not in self._names:
self._names.append(name)
self._fields[name] = field
def _validateOnAdd(self, field):
"""Validates fields on adding and bootstrapping
"""
# interface test
if not IField.providedBy(field):
raise ValueError, "Object doesn't implement IField: %r" % field
name = field.getName()
# two primary fields are forbidden
if getattr(field, 'primary', False):
res = self.hasPrimary()
if res is not False and name != res.getName():
raise SchemaException(
"Tried to add '%s' as primary field "
"but %s already has the primary field '%s'." %
(name, repr(self), res.getName())
)
for pname in ('accessor', 'edit_accessor', 'mutator'):
res = self._checkPropertyDupe(field, pname)
if res is not False:
res, value = res
raise SchemaException(
"Tried to add '%s' with property '%s' set "
"to %s but '%s' has the same value." %
(name, pname, repr(value), res.getName())
)
# Do not allowed unqualified references
if field.type in ('reference', ):
relationship = getattr(field, 'relationship', '')
if type(relationship) is not StringType or len(relationship) == 0:
raise ReferenceException(
"Unqualified relationship or "
"unsupported relationship var type in field '%s'. "
"The relationship qualifer must be a non empty "
"string." % name
)
def __delitem__(self, name):
if name not in self._fields:
raise KeyError("Schemata has no field '%s'" % name)
del self._fields[name]
self._names.remove(name)
def __getitem__(self, name):
return self._fields[name]
security.declareProtected(permissions.View, 'get')
def get(self, name, default=None):
return self._fields.get(name, default)
security.declareProtected(permissions.View, 'has_key')
def has_key(self, name):
return name in self._fields
__contains__ = has_key
security.declareProtected(permissions.View, 'keys')
def keys(self):
return self._names
security.declareProtected(permissions.ModifyPortalContent,
'delField')
delField = __delitem__
security.declareProtected(permissions.ModifyPortalContent,
'updateField')
updateField = addField
security.declareProtected(permissions.View, 'searchable')
def searchable(self):
"""Returns a list containing names of all searchable fields."""
return [f.getName() for f in self.fields() if f.searchable]
def hasPrimary(self):
"""Returns the first primary field or False"""
for f in self.fields():
if getattr(f, 'primary', False):
return f
return False
def _checkPropertyDupe(self, field, propname):
check_value = getattr(field, propname, _marker)
# None is fine too.
if check_value is _marker or check_value is None:
return False
check_name = field.getName()
for f in self.fields():
got = getattr(f, propname, _marker)
if got == check_value and f.getName() != check_name:
return f, got
return False
InitializeClass(Schemata)
class WrappedSchemata(Schemata, Explicit):
"""
Wrapped Schemata
"""
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
InitializeClass(WrappedSchemata)
class SchemaLayerContainer(DefaultLayerContainer):
"""Some layer management for schemas"""
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
_properties = {
'marshall': None
}
def __init__(self):
DefaultLayerContainer.__init__(self)
#Layer init work
marshall = self._props.get('marshall')
if marshall:
self.registerLayer('marshall', marshall)
# ILayerRuntime
security.declareProtected(permissions.ModifyPortalContent,
'initializeLayers')
def initializeLayers(self, instance, item=None, container=None):
# scan each field looking for registered layers optionally
# call its initializeInstance method and then the
# initializeField method
initializedLayers = []
called = lambda x: x in initializedLayers
for field in self.fields():
if ILayerContainer.providedBy(field):
layers = field.registeredLayers()
for layer, obj in layers:
if ILayer.providedBy(obj):
if not called((layer, obj)):
obj.initializeInstance(instance, item, container)
# Some layers may have the same name, but
# different classes, so, they may still
# need to be initialized
initializedLayers.append((layer, obj))
obj.initializeField(instance, field)
# Now do the same for objects registered at this level
if ILayerContainer.providedBy(self):
for layer, obj in self.registeredLayers():
if (not called((layer, obj)) and
ILayer.providedBy(obj)):
obj.initializeInstance(instance, item, container)
initializedLayers.append((layer, obj))
security.declareProtected(permissions.ModifyPortalContent,
'cleanupLayers')
def cleanupLayers(self, instance, item=None, container=None):
# scan each field looking for registered layers optionally
# call its cleanupInstance method and then the cleanupField
# method
queuedLayers = []
queued = lambda x: x in queuedLayers
for field in self.fields():
if ILayerContainer.providedBy(field):
layers = field.registeredLayers()
for layer, obj in layers:
if not queued((layer, obj)):
queuedLayers.append((layer, obj))
if ILayer.providedBy(obj):
obj.cleanupField(instance, field)
for layer, obj in queuedLayers:
if ILayer.providedBy(obj):
obj.cleanupInstance(instance, item, container)
# Now do the same for objects registered at this level
if ILayerContainer.providedBy(self):
for layer, obj in self.registeredLayers():
if (not queued((layer, obj)) and
ILayer.providedBy(obj)):
obj.cleanupInstance(instance, item, container)
queuedLayers.append((layer, obj))
def __add__(self, other):
c = SchemaLayerContainer()
layers = {}
for k, v in self.registeredLayers():
layers[k] = v
for k, v in other.registeredLayers():
layers[k] = v
for k, v in layers.items():
c.registerLayer(k, v)
return c
security.declareProtected(permissions.View, 'copy')
def copy(self):
c = SchemaLayerContainer()
layers = {}
for k, v in self.registeredLayers():
c.registerLayer(k, v)
return c
InitializeClass(SchemaLayerContainer)
class BasicSchema(Schemata):
"""Manage a list of fields and run methods over them."""
implements(ISchema)
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
_properties = {}
def __init__(self, *args, **kwargs):
"""
Initialize a Schema.
The first positional argument may be a sequence of
Fields. (All further positional arguments are ignored.)
Keyword arguments are added to my properties.
"""
Schemata.__init__(self)
self._props = self._properties.copy()
self._props.update(kwargs)
if len(args):
if type(args[0]) in [ListType, TupleType]:
for field in args[0]:
self.addField(field)
else:
msg = ('You are passing positional arguments '
'to the Schema constructor. '
'Please consult the docstring '
'for %s.BasicSchema.__init__' %
(self.__class__.__module__,))
level = 3
if self.__class__ is not BasicSchema:
level = 4
warn(msg, UserWarning, stacklevel=level)
for field in args:
self.addField(args[0])
def __add__(self, other):
c = BasicSchema()
# We can't use update and keep the order so we do it manually
for field in self.fields():
c.addField(field)
for field in other.fields():
c.addField(field)
# Need to be smarter when joining layers
# and internal props
c._props.update(self._props)
return c
security.declareProtected(permissions.View, 'copy')
def copy(self):
"""Returns a deep copy of this Schema.
"""
c = BasicSchema()
for field in self.fields():
c.addField(field.copy())
# Need to be smarter when joining layers
# and internal props
c._props.update(self._props)
return c
security.declareProtected(permissions.ModifyPortalContent, 'edit')
def edit(self, instance, name, value):
if self.allow(name):
instance[name] = value
security.declareProtected(permissions.ModifyPortalContent,
'setDefaults')
def setDefaults(self, instance):
"""Only call during object initialization. Sets fields to
schema defaults
"""
## TODO think about layout/vs dyn defaults
for field in self.values():
if field.getName().lower() == 'id': continue
if field.type == "reference": continue
# always set defaults on writable fields
mutator = field.getMutator(instance)
if mutator is None:
continue
default = field.getDefault(instance)
args = (default,)
kw = {'field': field.__name__,
'_initializing_': True}
if shasattr(field, 'default_content_type'):
# specify a mimetype if the mutator takes a
# mimetype argument
# if the schema supplies a default, we honour that,
# otherwise we use the site property
default_content_type = field.default_content_type
if default_content_type is None:
default_content_type = getDefaultContentType(instance)
kw['mimetype'] = default_content_type
mapply(mutator, *args, **kw)
security.declareProtected(permissions.ModifyPortalContent,
'updateAll')
def updateAll(self, instance, **kwargs):
"""This method mutates fields in the given instance.
For each keyword argument k, the key indicates the name of the
field to mutate while the value is used to call the mutator.
E.g. updateAll(instance, id='123', amount=500) will, depending on the
actual mutators set, result in two calls: ``instance.setId('123')`` and
``instance.setAmount(500)``.
"""
keys = kwargs.keys()
for name in keys:
field = self.get(name, None)
if field is None:
continue
if not field.writeable(instance):
continue
# If passed the test above, mutator is guaranteed to
# exist.
method = field.getMutator(instance)
method(kwargs[name])
security.declareProtected(permissions.View, 'allow')
def allow(self, name):
return name in self
security.declareProtected(permissions.View, 'validate')
def validate(self, instance=None, REQUEST=None,
errors=None, data=None, metadata=None):
"""Validate the state of the entire object.
The passed dictionary ``errors`` will be filled with human readable
error messages as values and the corresponding fields' names as
keys.
If a REQUEST object is present, validate the field values in the
REQUEST. Otherwise, validate the values currently in the object.
"""
if REQUEST:
fieldset = REQUEST.form.get('fieldset', None)
fieldsets = REQUEST.form.get('fieldsets', None)
else:
fieldset = fieldsets = None
fields = []
if fieldsets is not None:
schemata = instance.Schemata()
for fieldset in fieldsets:
fields += [(field.getName(), field)
for field in schemata[fieldset].fields()]
elif fieldset is not None:
schemata = instance.Schemata()
fields = [(field.getName(), field)
for field in schemata[fieldset].fields()]
else:
if data:
fields.extend([(field.getName(), field)
for field in self.filterFields(isMetadata=0)])
if metadata:
fields.extend([(field.getName(), field)
for field in self.filterFields(isMetadata=1)])
if REQUEST:
form = REQUEST.form
else:
form = None
for name, field in fields:
# Should not validate something we can't write to anyway
if not field.writeable(instance):
continue
error = 0
value = None
widget = field.widget
if widget.isVisible(instance, 'edit') != 'visible':
continue
if form:
result = widget.process_form(instance, field, form,
empty_marker=_marker)
else:
result = None
if result is None or result is _marker:
accessor = field.getEditAccessor(instance) or field.getAccessor(instance)
if accessor is not None:
value = accessor()
else:
# can't get value to validate -- bail
continue
else:
value = result[0]
res = field.validate(instance=instance,
value=value,
errors=errors,
REQUEST=REQUEST)
if res:
errors[field.getName()] = res
return errors
# Utility method for converting a Schema to a string for the
# purpose of comparing schema. This comparison is used for
# determining whether a schema has changed in the auto update
# function. Right now it's pretty crude.
# TODO FIXME!
security.declareProtected(permissions.View,
'toString')
def toString(self):
s = '%s: {' % self.__class__.__name__
for f in self.fields():
s = s + '%s,' % (f.toString())
s = s + '}'
return s
security.declareProtected(permissions.View,
'signature')
def signature(self):
try:
from hashlib import md5
except:
from md5 import md5
return md5(self.toString()).digest()
security.declareProtected(permissions.ModifyPortalContent,
'changeSchemataForField')
def changeSchemataForField(self, fieldname, schemataname):
""" change the schemata for a field """
field = self[fieldname]
self.delField(fieldname)
field.schemata = schemataname
self.addField(field)
security.declareProtected(permissions.View, 'getSchemataNames')
def getSchemataNames(self):
"""Return list of schemata names in order of appearing"""
lst = []
for f in self.fields():
if not f.schemata in lst:
lst.append(f.schemata)
return lst
security.declareProtected(permissions.View, 'getSchemataFields')
def getSchemataFields(self, name):
"""Return list of fields belong to schema 'name'
in order of appearing
"""
return [f for f in self.fields() if f.schemata == name]
security.declareProtected(permissions.ModifyPortalContent,
'replaceField')
def replaceField(self, name, field):
if IField.providedBy(field):
oidx = self._names.index(name)
new_name = field.getName()
self._names[oidx] = new_name
del self._fields[name]
self._fields[new_name] = field
else:
raise ValueError, "Object doesn't implement IField: %r" % field
InitializeClass(BasicSchema)
class Schema(BasicSchema, SchemaLayerContainer):
"""
Schema
"""
implements(ILayerRuntime, ILayerContainer, ISchema)
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
def __init__(self, *args, **kwargs):
BasicSchema.__init__(self, *args, **kwargs)
SchemaLayerContainer.__init__(self)
def __add__(self, other):
c = Schema()
# We can't use update and keep the order so we do it manually
for field in self.fields():
c.addField(field)
for field in other.fields():
c.addField(field)
# Need to be smarter when joining layers
# and internal props
c._props.update(self._props)
layers = {}
for k, v in self.registeredLayers():
layers[k] = v
for k, v in other.registeredLayers():
layers[k] = v
for k, v in layers.items():
c.registerLayer(k, v)
return c
security.declareProtected(permissions.View, 'copy')
def copy(self, factory=None):
"""Returns a deep copy of this Schema.
"""
if factory is None:
factory = self.__class__
c = factory()
for field in self.fields():
c.addField(field.copy())
# Need to be smarter when joining layers
# and internal props
c._props.update(self._props)
layers = {}
for k, v in self.registeredLayers():
c.registerLayer(k, v)
return c
security.declareProtected(permissions.View, 'wrapped')
def wrapped(self, parent):
schema = self.copy(factory=WrappedSchema)
return schema.__of__(parent)
security.declareProtected(permissions.ModifyPortalContent,
'moveField')
def moveField(self, name, direction=None, pos=None, after=None, before=None):
"""Move a field
>>> from Products.Archetypes.atapi import StringField as SF
>>> schema = Schema((SF('a'), SF('b'), SF('c'),))
>>> schema.keys()
['a', 'b', 'c']
>>> sbefore = schema.copy()
>>> sbefore.moveField('c', before='a')
>>> sbefore.keys()
['c', 'a', 'b']
>>> safter = schema.copy()
>>> safter.moveField('a', after='b')
>>> safter.keys()
['b', 'a', 'c']
>>> spos = schema.copy()
>>> spos.moveField('b', pos='top')
>>> spos.keys()
['b', 'a', 'c']
>>> spos = schema.copy()
>>> spos.moveField('b', pos='bottom')
>>> spos.keys()
['a', 'c', 'b']
>>> spos = schema.copy()
>>> spos.moveField('c', pos=0)
>>> spos.keys()
['c', 'a', 'b']
maxint can be used to move the field to the last position possible
>>> from sys import maxint
>>> spos = schema.copy()
>>> spos.moveField('a', pos=maxint)
>>> spos.keys()
['b', 'c', 'a']
Errors
======
>>> schema.moveField('d', pos=0)
Traceback (most recent call last):
...
KeyError: 'd'
>>> schema.moveField('a', pos=0, before='b')
Traceback (most recent call last):
...
ValueError: You must apply exactly one argument.
>>> schema.moveField('a')
Traceback (most recent call last):
...
ValueError: You must apply exactly one argument.
>>> schema.moveField('a', before='a')
Traceback (most recent call last):
...
ValueError: name and before can't be the same
>>> schema.moveField('a', after='a')
Traceback (most recent call last):
...
ValueError: name and after can't be the same
>>> schema.moveField('a', pos='foo')
Traceback (most recent call last):
...
ValueError: pos must be a number or top/bottom
"""
if bool(direction) + bool(after) + bool(before) + bool(pos is not None) != 1:
raise ValueError, "You must apply exactly one argument."
keys = self.keys()
if name not in keys:
raise KeyError, name
if direction is not None:
return self._moveFieldInSchemata(name, direction)
if pos is not None:
if not (isinstance(pos, int) or pos in ('top', 'bottom',)):
raise ValueError, "pos must be a number or top/bottom"
if pos == 'top':
return self._moveFieldToPosition(name, 0)
elif pos == 'bottom':
return self._moveFieldToPosition(name, len(keys))
else:
return self._moveFieldToPosition(name, pos)
if after is not None:
if after == name:
raise ValueError, "name and after can't be the same"
idx = keys.index(after)
return self._moveFieldToPosition(name, idx + 1)
if before is not None:
if before == name:
raise ValueError, "name and before can't be the same"
idx = keys.index(before)
return self._moveFieldToPosition(name, idx)
def _moveFieldToPosition(self, name, pos):
"""Moves a field with the name 'name' to the position 'pos'
This method doesn't obey the assignement of fields to a schemata
"""
keys = self._names
oldpos = keys.index(name)
keys.remove(name)
if oldpos >= pos:
keys.insert(pos, name)
else:
keys.insert(pos - 1, name)
self._names = keys
def _moveFieldInSchemata(self, name, direction):
"""Moves a field with the name 'name' inside its schemata
"""
if not direction in (-1, 1):
raise ValueError, "Direction must be either -1 or 1"
fields = self.fields()
fieldnames = [f.getName() for f in fields]
schemata_names = self.getSchemataNames()
field = self[name]
field_schemata_name = self[name].schemata
d = {}
for s_name in self.getSchemataNames():
d[s_name] = self.getSchemataFields(s_name)
lst = d[field_schemata_name] # list of fields of schemata
pos = [f.getName() for f in lst].index(field.getName())
if direction == -1:
if pos > 0:
del lst[pos]
lst.insert(pos - 1, field)
if direction == 1:
if pos < len(lst):
del lst[pos]
lst.insert(pos + 1, field)
d[field_schemata_name] = lst
# remove and re-add
self.__init__()
for s_name in schemata_names:
for f in d[s_name]:
self.addField(f)
InitializeClass(Schema)
class WrappedSchema(Schema, Explicit):
"""
Wrapped Schema
"""
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
InitializeClass(WrappedSchema)
class ManagedSchema(Schema):
"""
Managed Schema
"""
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
implements(IManagedSchema)
security.declareProtected(permissions.ModifyPortalContent,
'delSchemata')
def delSchemata(self, name):
"""Remove all fields belonging to schemata 'name'"""
for f in self.fields():
if f.schemata == name:
self.delField(f.getName())
security.declareProtected(permissions.ModifyPortalContent,
'addSchemata')
def addSchemata(self, name):
"""Create a new schema by adding a new field with schemata 'name' """
from Products.Archetypes.Field import StringField
if name in self.getSchemataNames():
raise ValueError, "Schemata '%s' already exists" % name
self.addField(StringField('%s_default' % name, schemata=name))
security.declareProtected(permissions.ModifyPortalContent,
'moveSchemata')
def moveSchemata(self, name, direction):
"""Move a schemata to left (direction=-1) or to right
(direction=1)
"""
if not direction in (-1, 1):
raise ValueError, 'Direction must be either -1 or 1'
fields = self.fields()
fieldnames = [f.getName() for f in fields]
schemata_names = self.getSchemataNames()
d = {}
for s_name in self.getSchemataNames():
d[s_name] = self.getSchemataFields(s_name)
pos = schemata_names.index(name)
if direction == -1:
if pos > 0:
schemata_names.remove(name)
schemata_names.insert(pos - 1, name)
if direction == 1:
if pos < len(schemata_names):
schemata_names.remove(name)
schemata_names.insert(pos + 1, name)
# remove and re-add
self.__init__()
for s_name in schemata_names:
for f in fields:
if f.schemata == s_name:
self.addField(f)
InitializeClass(ManagedSchema)
# Reusable instance for MetadataFieldList
MDS = MetadataStorage()
class MetadataSchema(Schema):
"""Schema that enforces MetadataStorage."""
security = ClassSecurityInfo()
security.setDefaultAccess('allow')
security.declareProtected(permissions.ModifyPortalContent,
'addField')
def addField(self, field):
"""Strictly enforce the contract that metadata is stored w/o
markup and make sure each field is marked as such for
generation and introspcection purposes.
"""
_properties = {'isMetadata': 1,
'storage': MetadataStorage(),
'schemata': 'metadata',
'generateMode': 'mVc'}
field.__dict__.update(_properties)
field.registerLayer('storage', field.storage)
Schema.addField(self, field)
InitializeClass(MetadataSchema)
FieldList = Schema
MetadataFieldList = MetadataSchema
