def __call__(self, value): if IField.providedBy(self.field.key_type): kdeserializer = getMultiAdapter( (self.field.key_type, self.context, self.request), IFieldDeserializer ) else: def kdeserializer(k): return k if IField.providedBy(self.field.value_type): vdeserializer = getMultiAdapter( (self.field.value_type, self.context, self.request), IFieldDeserializer ) else: def vdeserializer(v): return v new_value = {} for k, v in value.items(): new_value[kdeserializer(k)] = vdeserializer(v) self.field.validate(new_value) return new_value
def __init__(self, key_type=None, value_type=None, **kw): super(Dict, self).__init__(**kw) # whine if key_type or value_type is not a field if key_type is not None and not IField.providedBy(key_type): raise ValueError("'key_type' must be field instance.") if value_type is not None and not IField.providedBy(value_type): raise ValueError("'value_type' must be field instance.") self.key_type = key_type self.value_type = value_type
def __call__(self, value): kdeserializer = lambda k: k vdeserializer = lambda v: v if IField.providedBy(self.field.key_type): kdeserializer = getMultiAdapter((self.field.key_type, self.context, self.request), IFieldDeserializer) if IField.providedBy(self.field.value_type): vdeserializer = getMultiAdapter((self.field.value_type, self.context, self.request), IFieldDeserializer) new_value = {} for k, v in value.items(): new_value[kdeserializer(k)] = vdeserializer(v) self.field.validate(new_value) return new_value
def __init__(self, value_type=None, unique=False, **kw): super(AbstractCollection, self).__init__(**kw) # whine if value_type is not a field if value_type is not None and not IField.providedBy(value_type): raise ValueError("'value_type' must be field instance.") self.value_type = value_type self.unique = unique
def __call__(self, context): # we take the fti type settings to get the selected connections and table if ISQLTypeSchemaContext.providedBy(context): context = ISQLTypeSettings(context.fti) elif IField.providedBy(context): context = ISQLTypeSettings(aq_parent(context.context).fti) urls = ISQLAlchemyConnectionStrings( component.getUtility(ISiteRoot)).values() if not getattr(context, 'sql_connection', None) or not getattr( context, 'sql_table', None): return SimpleVocabulary([]) columns = [] if not ISQLTypeSettings.providedBy(context): context = ISQLTypeSettings(context) sql_url = context.sql_url sql_table = context.sql_table engine = create_engine(sql_url) insp = reflection.Inspector.from_engine(engine) columns = insp.get_columns(sql_table) columns.sort(lambda x, y: cmp(x.get('name'), y.get('name'))) items = [ SimpleTerm(a.get('name'), a.get('name'), a.get('name') + ' (' + str(a.get('type')) + ')') for a in columns if a.get('name') and 'TIMESTAMP' in str(a.get('type')) ] return SimpleVocabulary(items)
def __call__(self, context): # we take the fti type settings to get the selected connections and table if ISQLTypeSchemaContext.providedBy(context): context = ISQLTypeSettings(context.fti) elif IField.providedBy(context): context = ISQLTypeSettings(aq_parent(context.context).fti) urls = ISQLAlchemyConnectionStrings(component.getUtility(ISiteRoot)).values() if not getattr(context, 'sql_table', None): return SimpleVocabulary([]) items = [] connection = queryUtility(ISQLConnectionsUtility, name=context.id, default=None) if not connection: connection = registerConnectionUtilityForFTI(context.context) columns = [] for a in inspect(connection.tableClass).columns: if a.name: items.append(SimpleTerm(a.name, a.name, a.name+' ('+str(a.type)+')')) columns.append(a.name) for a in getattr(inspect(connection.tableClass), 'relationships', []): if a.key in columns: continue items.append(SimpleTerm(a.key, a.key, a.key+' (Relation)')) for b in inspect(a.table).columns: if b.name: items.append(SimpleTerm(a.key+'.'+b.name, a.key+'.'+b.name, a.key+'.'+b.name+' ('+str(b.type)+')')) columns.append(a.key+'.'+b.name) # for b in getattr(inspect(connection.tableClass), 'relationships', []): # if a.key+'.'+b.key in columns: # continue # items.append(SimpleTerm(a.key+'.'+b.key, a.key+'.'+b.key, a.key+'.'+b.key+' (Relation)')) items.sort( lambda x, y: cmp(x.value, y.value ) ) return SimpleVocabulary(items)
def __call__(self, context): # we take the fti type settings to get the selected connections and table if ISQLTypeSchemaContext.providedBy(context): context = ISQLTypeSettings(context.fti) elif IField.providedBy(context): context = ISQLTypeSettings(aq_parent(context.context).fti) urls = ISQLAlchemyConnectionStrings(component.getUtility(ISiteRoot)).values() if not getattr(context, 'sql_table', None): return SimpleVocabulary([]) columns = [] sql_connection = context.sql_connection sql_table = context.sql_table engine = create_engine(sql_connection) insp = reflection.Inspector.from_engine(engine) base_columns = insp.get_columns(sql_table) columns = set() for constraint in insp.get_unique_constraints(sql_table): if len(constraint.get('column_names')) == 1: columns.update(constraint.get('column_names')[0]) columns = columns.union(set(insp.get_pk_constraint(sql_table).get('constrained_columns'))) columns = list(columns) final = [] for col in base_columns: if col['name'] not in columns: continue final.append(col.copy()) final.sort( lambda x, y: cmp(x.get('name'), y.get('name') ) ) items = [SimpleTerm(a.get('name'), a.get('name'), a.get('name')+' ('+str(a.get('type'))+')') for a in final if a.get('name')] return SimpleVocabulary(items)
def __call__(self): # Binding is necessary for named vocabularies if IField.providedBy(self.field): self.field = self.field.bind(self.context) value = self.get_value() value_type = self.field.value_type if ( value is not None and IChoice.providedBy(value_type) and IVocabularyTokenized.providedBy(value_type.vocabulary) ): values = [] for v in value: try: term = value_type.vocabulary.getTerm(v) values.append({"token": term.token, "title": term.title}) except LookupError: log.warning( "Term lookup error: %r %s (%s:%s)" % ( v, self.field.title, self.context.portal_type, self.context.absolute_url(1), ) ) value = values return json_compatible(value)
def what_changed(sqlobject_modified_event): before = sqlobject_modified_event.object_before_modification after = sqlobject_modified_event.object fields = sqlobject_modified_event.edited_fields changes = {} for fieldname in fields: # XXX 2011-01-21 gmb bug=705955: # Sometimes, something (webservice, I'm looking at you # here), will create an ObjectModifiedEvent where the # edited_fields list is actually a list of field instances # instead of strings. We special-case that here, but we # shouldn't have to. if IField.providedBy(fieldname): fieldname = fieldname.getName() val_before = getattr(before, fieldname, None) val_after = getattr(after, fieldname, None) #XXX Bjorn Tillenius 2005-06-09: This shouldn't be necessary. # peel off the zope stuff if isProxy(val_before): val_before = removeSecurityProxy(val_before) if isProxy(val_after): val_after = removeSecurityProxy(val_after) before_string = get_string_representation(val_before) after_string = get_string_representation(val_after) if before_string != after_string: changes[fieldname] = [before_string, after_string] return changes
def __init__(self, fields, **kw): for ix, field in enumerate(fields): if not IField.providedBy(field): raise DoesNotImplement(IField) field.__name__ = "combination_%02d" % ix self.fields = tuple(fields) super(Combination, self).__init__(**kw)
def writeAttribute(self, attributeField, field, ignoreDefault=True): """Create and return a element that describes the given attribute field on the given field """ elementName = attributeField.__name__ attributeField = attributeField.bind(field) value = attributeField.get(field) force = (elementName in self.forcedFields) if ignoreDefault and value == attributeField.default: return None # The value points to another field. Recurse. if IField.providedBy(value): value_fieldType = IFieldNameExtractor(value)() handler = queryUtility(IFieldExportImportHandler, name=value_fieldType) if handler is None: return None return handler.write(value, name=None, type=value_fieldType, elementName=elementName) # For 'default', 'missing_value' etc, we want to validate against # the imported field type itself, not the field type of the attribute if elementName in self.fieldTypeAttributes or \ elementName in self.nonValidatedfieldTypeAttributes: attributeField = field return valueToElement(attributeField, value, name=elementName, force=force)
def getValAttributeNames(arg_instance): """return a string list of instance attribute names """ classOfInstance = arg_instance.__class__ #(Pdb) pp classOfInstance.__dict__['address1'] #<zope.schema.fieldproperty.FieldProperty object at 0xb86d1ec> #(Pdb) getattr(classOfInstance, attrName) #*** AttributeError: type object 'Address' has no attribute '__annotations__' #(Pdb) hasattr(classOfInstance, attrName) #False retList = [] classInheritancePath = getClassInheritancePath(classOfInstance, endClass=Superclass) classInheritancePath.append(classOfInstance) print "classInheritancePath: ", classInheritancePath askAttributes = [] allAttributesList = [ i_class.__dict__.keys() for i_class in classInheritancePath ] for j_attrList in allAttributesList: askAttributes.extend(j_attrList) from zope.interface import Attribute for attrName, attrValue in arg_instance.__dict__.items(): if hasattr(classOfInstance, attrName): classField = getattr(classOfInstance, attrName) #print "%s: (%s): %s" % (attrName, classField, isinstance(classField, Attribute)) if IField.providedBy(classField) and \ attrName in askAttributes: retList.append(attrName) #print "dumdidumm: ", retList return retList
def _validate_fields(schema, value, errors=None): if errors is None: errors = [] # Interface can be used as schema property for Object fields that plan to # hold values of any type. # Because Interface does not include any Attribute, it is obviously not # worth looping on its methods and filter them all out. if schema is Interface: return errors # if `value` is part of a cyclic graph, we need to break the cycle to avoid # infinite recursion. # # (use volatile attribute to avoid persistency/conflicts) if hasattr(value, '_v_schema_being_validated'): return errors # Mark the value as being validated. value._v_schema_being_validated = True # (If we have gotten here, we know that `value` provides an interface # other than zope.interface.Interface; # iow, we can rely on the fact that it is an instance # that supports attribute assignment.) try: for name in schema.names(all=True): if not IMethod.providedBy(schema[name]): try: attribute = schema[name] if IField.providedBy(attribute): # validate attributes that are fields attribute.validate(getattr(value, name)) except ValidationError, error: errors.append(error) except AttributeError, error: # property for the given name is not implemented errors.append(SchemaNotFullyImplemented(error))
def __call__(self): # Binding is necessary for named vocabularies if IField.providedBy(self.field): self.field = self.field.bind(self.context) value = self.get_value() # XXX with elephanvocabulary, "real" vocab is stored on vocabulary.vocab vocab = getattr(self.field.vocabulary, "vocab", self.field.vocabulary) if value is not None and IVocabularyTokenized.providedBy(vocab): try: term = self.field.vocabulary.getTerm(value) # If not found, get it from the z3c.form that maybe uses a MissingTerms adapter... except LookupError: try: view = self.context.restrictedTraverse("@@view") view.update() # widget_name is the field name prefixed with behavior if any widget_name = [field for field in get_schema_fields(self.context, prefix=True) if field[1].__name__ == self.field.__name__][0][0] widget = view.widgets[widget_name] term = widget.terms.getTerm(value) except Exception: # at worse use value as title term = SimpleTerm(value, title=value) finally: value = {"token": term.token, "title": term.title} return json_compatible(value)
def portletManagerDirective( _context, name, title, for_=None, description=u'', class_=None, schema=None, layer=IDefaultBrowserLayer, provides=(), portlettype=IPortlet, **kw): # Build a new class ManagerClass = PortletManager( name, class_, provides, title, description, schema, portlettype, **kw) # Set up permission mapping for various accessible attributes required = {'__call__': CheckerPublic, 'browserDefault': CheckerPublic, 'publishTraverse': CheckerPublic} for iname in IPortletManager: required[iname] = CheckerPublic # security checker defineChecker(ManagerClass, Checker(required)) # security for schema fields for iface in (IPortletManagerConfiguration, schema): if iface is None: continue for f_id in iface: field = iface[f_id] if IField.providedBy(field) and not field.readonly: protectSetAttribute(ManagerClass, f_id, 'zojax.ManagePortlets') protectName(ManagerClass, f_id, 'zope.Public') # register the portlet manager adapter(_context, (ManagerClass,), IPortletManager, (for_, layer, None), name=name)
def export_assignment(self, interface, doc, node): for field_name in interface: field = interface[field_name] if not IField.providedBy(field): continue child = self.export_field(doc, field) node.appendChild(child)
def schema_from_model(model): table = model.__table__ bases = (Interface,) attrs = {} for i, column in enumerate(table.columns): if len(column.foreign_keys) or column.primary_key: continue field = IField(column.type) field.__name__ = str(column.name) field.title = unicode(column.name) field.required = not column.nullable attrs[column.name] = field field.order = i return InterfaceClass(name=model.__table__.name, bases=bases, attrs=attrs, __doc__='Generated from metadata')
def __init__(self, field, name=None, klass=None, **args): if not IField.providedBy(field): raise ValueError("Provided field must implement IField interface...") if name is None: name = field.__name__ self.__field = field self.__name = name self.__klass = klass self.__args = args
def export_assignment(self, interface, doc, node): for field_name in sorted(interface): field = interface[field_name] if not IField.providedBy(field): continue child = self.export_field(doc, field) node.appendChild(child)
def Fields(*args, **kw): fields = [] for key, value in kw.items(): if IField.providedBy(value): value.__name__ = key fields.append(value) del kw[key] fields.sort(key=lambda field: field.order) return form.Fields(*(args + tuple(fields)), **kw)
def __init__(self, fields, **kw): if len(fields) < 2: raise ValueError(_("combination must combine two or more fields")) for ix, field in enumerate(fields): if not IField.providedBy(field): raise DoesNotImplement(IField) field.__name__ = "combination_%02d" % ix self.fields = tuple(fields) super(Combination, self).__init__(**kw)
def __init__(self, fields, use_default_for_not_selected=False, **kw): if len(fields) < 2: raise ValueError(_("union must combine two or more fields")) for ix, field in enumerate(fields): if not IField.providedBy(field): raise DoesNotImplement(IField) field.__name__ = "unioned_%02d" % ix self.fields = tuple(fields) self.use_default_for_not_selected = use_default_for_not_selected super(Union, self).__init__(**kw)
def sortedFields(schema): """Like getFieldsInOrder, but does not include fields from bases """ fields = [] for name in schema.names(all=False): field = schema[name] if IField.providedBy(field): fields.append((name, field, )) fields.sort(key=lambda item: item[1].order) return fields
def traverse(self, name, ignore): field = providedBy(self.context).get(name) if field is not None and IField.providedBy(field): value = getattr(self.context, name, _marker) if value is not _marker: bound_field = field.bind(value) bound_field.__parent__ = self.context return bound_field raise NotFound(self.context, name, self.request)
def getFields(schema): """Return a dictionary containing all the Fields in a schema. """ from zope.schema.interfaces import IField fields = {} for name in schema: attr = schema[name] if IField.providedBy(attr): fields[name] = attr return fields
def __init__(self, value_type=_NotGiven, unique=_NotGiven, **kw): super(Collection, self).__init__(**kw) # whine if value_type is not a field if value_type is not _NotGiven: self.value_type = value_type if self.value_type is not None and not IField.providedBy(self.value_type): raise ValueError("'value_type' must be field instance.") if unique is not _NotGiven: self.unique = unique
def __init__(self, field, factory, name=None): if not IField.providedBy(field): raise ValueError("Provided field must be an IField object") if not IFile.implementedBy(factory): raise ValueError("Provided factory is not a valid IFile") self.__field = field self.__name = name or field.__name__ self.__factory = factory
def export_element(self, doc, node): if self.descriptor.schema is None: return for field_name in self.descriptor.schema: field = self.descriptor.schema[field_name] if not IField.providedBy(field): continue child = self.export_field(doc, field) node.appendChild(child)
def __call__(self, context): # we take the fti type settings to get the selected connections and table # on adding, guess the portal_type request = getattr(context, 'REQUEST', None) request_url = hasattr(request, 'get') and request.get('URL') or '' if '++add++' in request_url: portal_type = context.REQUEST.get('URL').split('++add++')[1] fti = queryUtility(IDexterityFTI, name=portal_type, default=None) if fti: context = ISQLTypeSettings(fti) elif ISQLTypeSchemaContext.providedBy(context): context = ISQLTypeSettings(context.fti) elif ISQLDexterityItem.providedBy(context): fti = queryUtility(IDexterityFTI, name=context.portal_type, default=None) if fti: context = ISQLTypeSettings(fti) elif IField.providedBy(context): context = ISQLTypeSettings(aq_parent(context.context).fti) urls = ISQLAlchemyConnectionStrings( component.getUtility(ISiteRoot)).values() if not urls or not getattr( context, 'sql_connection', None) or not getattr( context, 'sql_table', None) or not getattr( context, 'sql_id_column', None): return SimpleVocabulary([]) ids = [] sql_table = context.sql_table sql_id_column = context.sql_id_column s = text('SELECT ' + sql_id_column + ' FROM ' + sql_table) connection = queryUtility(ISQLConnectionsUtility, name=context.id, default=None) if not connection: connection = registerConnectionUtilityForFTI(context.context) try: res = connection.conn.execute(s).fetchall() except: connection.reinit() res = connection.conn.execute(s).fetchall() items = [] for a in res: title = a[0] try: title = str(a[0]) except: try: title = str(a[0].encode('utf-8')) except: title = str(a[0].decode('utf-8')) items.append(SimpleTerm(title, title, title)) return SimpleVocabulary(items)
def schema_indexes(context): if IField.providedBy(context): _index_types = schema_index_types(context) _name = lambda idx, n: '%s_%s' % (idx, n) name = context.__name__ return tuple(_name(idx, name) for idx in _index_types) if IInterface.providedBy(context): r = [] for name, field in getFieldsInOrder(context): r += list(schema_indexes(field)) return tuple(r) raise ValueError('context must be interface or field')
def schema_indexes(context): if IField.providedBy(context): _index_types = schema_index_types(context) _name = lambda idx, n: "%s_%s" % (idx, n) name = context.__name__ return tuple(_name(idx, name) for idx in _index_types) if IInterface.providedBy(context): r = [] for name, field in getFieldsInOrder(context): r += list(schema_indexes(field)) return tuple(r) raise ValueError("context must be interface or field")
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 = 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': result['properties'] = self.field.schema return result
def is_reference_field(self, field): """Checks if the field is a reference field type """ if not field: return False if IField.providedBy(field): # TODO: At the moment we do not have a dexterity based reference # field. Implement this when we have an interface for this. return False field_type = getattr(field, "type", None) if field_type is None: return False return field.type in REF_FIELD_TYPES
def sortedFields(schema): """ Like getFieldsInOrder, but does not include fields from bases This is verbatim from plone.supermodel's utils.py but I didn't want to create a dependency. """ fields = [] for name in schema.names(all=False): field = schema[name] if IField.providedBy(field): fields.append((name, field,)) fields.sort(key=lambda item: item[1].order) return fields
def __protectSetSchema(self, schema, permission_id): "Set a permission on a bunch of names." _context = self.__context for name in schema: field = schema[name] if IField.providedBy(field) and not field.readonly: _context.action(discriminator=('protectSetAttribute', self.__class, name), callable=protectSetAttribute, args=(self.__class, name, permission_id)) _context.action(discriminator=None, callable=provideInterface, args=(schema.__module__ + '.' + schema.getName(), schema))
def __call__(self, value): if not isinstance(value, list): value = [value] if IField.providedBy(self.field.value_type): deserializer = getMultiAdapter((self.field.value_type, self.context, self.request), IFieldDeserializer) for i, v in enumerate(value): value[i] = deserializer(v) value = self.field._type(value) self.field.validate(value) return value
def _marshall_from_json_data(self, value): """See `SimpleFieldMarshaller`.""" template = {} for name in self.field.schema.names(all=True): field = self.field.schema[name] if IField.providedBy(field): marshaller = getMultiAdapter( (field, self.request), IFieldMarshaller) if marshaller.representation_name in value: template[name] = marshaller.marshall_from_json_data( value[marshaller.representation_name]) elif field.required: raise RequiredMissing(name) return self.field.schema(template)
def __call__(self): # Binding is necessary for named vocabularies if IField.providedBy(self.field): self.field = self.field.bind(self.context) value = self.get_value() value_type = self.field.value_type if (value is not None and IChoice.providedBy(value_type) and IVocabularyTokenized.providedBy(value_type.vocabulary)): values = [] for v in value: term = value_type.vocabulary.getTerm(v) values.append({u"token": term.token, u"title": term.title}) value = self.field._type(values) return json_compatible(value)
def __init__(self, *args, **kw): # Most of this code is copied from zope.formlib.form.Formfields # licensed under the ZPL 2.1 keep_readonly, omit_readonly, defaults = _initkw(**kw) fields = [] fieldsets = () for arg in args: if isinstance(arg, InterfaceClass): for name, field in getFieldsInOrder(arg): fields.append((name, field)) elif IField.providedBy(arg): name = arg.__name__ if not name: raise ValueError("Field has no name") fields.append((name, arg)) elif isinstance(arg, FormFieldsets): fieldsets = fieldsets + (arg, ) for form_field in arg: fields.append((form_field.__name__, form_field)) elif isinstance(arg, FormFields): for form_field in arg: fields.append((form_field.__name__, form_field)) elif isinstance(arg, FormField): fields.append((arg.__name__, arg)) else: raise TypeError("Unrecognized argument type", arg) self.fieldsets = fieldsets seq = [] byname = {} for name, field in fields: if isinstance(field, FormField): form_field = field else: if field.readonly: if omit_readonly and (name not in keep_readonly): continue form_field = FormField(field, **defaults) name = form_field.__name__ if name in byname: raise ValueError("Duplicate name", name) seq.append(form_field) byname[name] = form_field self.__FormFields_seq__ = seq self.__FormFields_byname__ = byname
def _validate_fields(schema, value, errors=None): if errors is None: errors = [] for name in schema.names(all=True): if not IMethod.providedBy(schema[name]): try: attribute = schema[name] if IField.providedBy(attribute): # validate attributes that are fields attribute.validate(getattr(value, name)) except ValidationError, error: errors.append(error) except AttributeError, error: # property for the given name is not implemented errors.append(SchemaNotFullyImplemented(error))
def __getattr__(self, name): schema = self._FormData_schema___ data = self._FormData_data___ context = self._FormData_context___ try: field = schema[name] except KeyError: raise AttributeError(name) else: value = data.get(name, data) if value is data: if context is None: raise NoInputData(name) # The value is not in the form look it up on the context: field = schema[name] adapted_context = schema(context) if IField.providedBy(field): value = field.get(adapted_context) elif (zope.interface.interfaces.IAttribute.providedBy(field) and not zope.interface.interfaces.IMethod.providedBy(field)): # Fallback for non-field schema contents: value = getattr(adapted_context, name) else: # Don't know how to extract value raise NoInputData(name) if zope.interface.interfaces.IMethod.providedBy(field): if not IField.providedBy(field): raise RuntimeError( "Data value is not a schema field", name) v = lambda: value else: v = value setattr(self, name, v) return v raise AttributeError(name)
def __init__(self, *args, **kw): keep_readonly, omit_readonly, defaults = _initkw(**kw) fields = [] for arg in args: if isinstance(arg, InterfaceClass): for name, field in schema.getFieldsInOrder(arg): fields.append((name, field, arg)) elif IField.providedBy(arg): name = arg.__name__ if not name: raise ValueError( "Field has no name") fields.append((name, arg, arg.interface)) elif isinstance(arg, FormFields): for form_field in arg: fields.append( (form_field.__name__, form_field, form_field.interface) ) elif isinstance(arg, FormField): fields.append((arg.__name__, arg, arg.interface)) else: raise TypeError("Unrecognized argument type", arg) seq = [] byname = {} for name, field, iface in fields: if isinstance(field, FormField): form_field = field else: if field.readonly: if omit_readonly and (name not in keep_readonly): continue form_field = FormField(field, interface=iface, **defaults) name = form_field.__name__ if name in byname: raise ValueError("Duplicate name", name) seq.append(form_field) byname[name] = form_field self.__FormFields_seq__ = seq self.__FormFields_byname__ = byname
def cloneField(self, field): # XXX: The field may sometimes not have data for reasons known only # to Jim. try: field._p_activate() except AttributeError: pass clone = field.__class__.__new__(field.__class__) clone.__dict__.update(field.__dict__) for name, attr in field.__dict__.items(): if IField.providedBy(attr): clone.__dict__[name] = self.cloneField(attr) return clone
def __protectSetSchema(self, schema, permission_id): "Set a permission on a bunch of names." _context = self._context for name in schema: field = schema[name] if IField.providedBy(field) and not field.readonly: _context.action( discriminator = ('zojax:controlpanel:protectSetAttribute', self._class, name, object()), callable = protectSetAttribute, args = (self._class, name, permission_id)) _context.action( discriminator = None, callable = provideInterface, args = (schema.__module__+'.'+schema.getName(), schema))