Python schema.getFieldsInOrder函数代码示例

def get_ttw_fields(obj):
    """Returns names of the fields that were added to obj through the web"""
    fti = getUtility(IDexterityFTI, name=obj.portal_type)
    full_schema = fti.lookupSchema()
    all_fields = schema.getFieldsInOrder(full_schema)

    schema_policy = getUtility(ISchemaPolicy, name=fti.schema_policy)
    original_schema = schema_policy.bases(None, None)[0]
    original_fields = schema.getFieldsInOrder(original_schema)
    new_fields = [field[0] for field in all_fields
                  if field[0] not in dict(original_fields).keys()]

    for behavior_id in fti.behaviors:
        behavior = getUtility(IBehavior, behavior_id).interface
        if behavior == IContactDetails or not IFormFieldProvider.providedBy(behavior):
            continue

        try:
            default_fieldset_fields = non_fieldset_fields(behavior)
            behavior_name = behavior_id.split('.')[-1]
            # @TODO: get generic method to get widget id
            new_fields.extend(['%s.%s' % (behavior_name, field_name)
                               for field_name in default_fieldset_fields])
        except:
            pass

    return new_fields

    def _fields(self):
        """
        """
        context = self.context
        behavior_fields = []

        # Stap 1 metadata
        behavior_assignable = IBehaviorAssignable(context)
        if behavior_assignable:
            behaviors = behavior_assignable.enumerateBehaviors()
            for behavior in behaviors:
                behavior_fields += getFieldsInOrder(behavior.interface)

        # Stap 2 eigen velden
        fti = context.getTypeInfo()
        schema = fti.lookupSchema()
        content_fields = getFieldsInOrder(schema)
        fields = behavior_fields
        fields += content_fields
        
#        for field_info in fields:
#            try:
#                field_name = field_info[0]
#                field = field_info[1]
#                print field_info
#                print getattr(context, field_name)
#            except Exception, e:
#                pass
            
        return fields

def get_schema_fields(model_or_obj, marker=None):
    for schema in get_schemas(model_or_obj):
        for name, field in getFieldsInOrder(schema):
            yield name, field, schema

    if model_implements_marker(model_or_obj, marker):
        for name, field in getFieldsInOrder(marker):
            yield name, field, marker

    def __call__(self, context, query=None):
        results = []
        field_ids = []
        exclude = ['im_handle', 'use_parent_address']
        exclude_behaviors = ['plone.app.content.interfaces.INameFromTitle']
        behaviors = set()
        portal_types = api.portal.get_tool('portal_types')
        contact_portal_types = ['person', 'organization', 'position', 'held_position']  # noqa
        for contact_portal_type in contact_portal_types:
            schema = getUtility(
                IDexterityFTI, name=contact_portal_type).lookupSchema()
            fieldsets = mergedTaggedValueList(schema, FIELDSETS_KEY)
            for name, field in getFieldsInOrder(schema):
                if name not in exclude and name not in field_ids:
                    visible_name = u'{0}: {1}'.format(
                        contact_portal_type, field.title)
                    field_ids.append(name)
                    results.append((name, visible_name))

            portal_type = getattr(portal_types, contact_portal_type)
            behaviors.update(set(portal_type.behaviors))
        try:
            # remove duplicates photo
            results.remove(('photo', u'held_position: Photo'))
        except ValueError:
            pass
        for behavior in behaviors:
            if behavior not in exclude_behaviors:
                try:
                    # not able to get fields from IDirectoryContactDetails
                    # with nameToInterface(context, behavior)
                    if behavior == 'cpskin.core.behaviors.directorycontact.IDirectoryContactDetails':  # noqa
                        from cpskin.core.behaviors.directorycontact import (
                            IDirectoryContactDetails)
                        interface = IDirectoryContactDetails
                    else:
                        interface = nameToInterface(context, behavior)
                    fieldsets = mergedTaggedValueList(interface, FIELDSETS_KEY)
                    for name, field in getFieldsInOrder(interface):
                        if name not in exclude and name not in field_ids:
                            if not fieldsets:
                                visible_name = field.title
                            else:
                                fieldset = [
                                    fieldset for fieldset in fieldsets if name in fieldset.fields  # noqa
                                ][0]
                                field_ids.append(name)
                                visible_name = u'{0}: {1}'.format(
                                    fieldset.label, field.title)
                            results.append((name, visible_name))
                except:
                    pass
        items = [
            SimpleTerm(i, i, j)
            for i, j in results if j
        ]
        return SimpleVocabulary(items)

def get_ttw_fields(obj):
    """Returns names of the fields that were added to obj through the web"""
    fti = getUtility(IDexterityFTI, name=obj.portal_type)
    full_schema = fti.lookupSchema()
    all_fields = schema.getFieldsInOrder(full_schema)

    schema_policy = getUtility(ISchemaPolicy, name=fti.schema_policy)
    original_schema = schema_policy.bases(None, None)[0]
    original_fields = schema.getFieldsInOrder(original_schema)
    new_fields = frozenset(dict(all_fields).keys()) - \
                 frozenset(dict(original_fields).keys())
    return new_fields

 def _all_fields(self):
     type_info = self.context.getTypeInfo()
     if type_info is None:
         return
     schema = type_info.lookupSchema()
     for field in getFieldsInOrder(schema):
         yield field
     behavior_assignable = IBehaviorAssignable(self.context)
     if behavior_assignable:
         for behavior in behavior_assignable.enumerateBehaviors():
             for field in getFieldsInOrder(behavior.interface):
                 yield field

def get_ordered_fields(fti):
    """ return fields in fieldset order """
    # NOTE: code extracted from collective.excelexport. Original comments
    # preserved

    # this code is much complicated because we have to get sure
    # we get the fields in the order of the fieldsets
    # the order of the fields in the fieldsets can differ
    # of the getFieldsInOrder(schema) order...
    # that's because fields from different schemas
    # can take place in the same fieldset
    schema = fti.lookupSchema()
    fieldset_fields = {}
    ordered_fieldsets = ['default']

    for fieldset in schema.queryTaggedValue(FIELDSETS_KEY, []):
        ordered_fieldsets.append(fieldset.__name__)
        fieldset_fields[fieldset.__name__] = fieldset.fields

    if fieldset_fields.get('default', []):
        fieldset_fields['default'] += non_fieldset_fields(schema)
    else:
        fieldset_fields['default'] = non_fieldset_fields(schema)

    # Get the behavior fields
    fields = getFieldsInOrder(schema)

    for behavior_id in fti.behaviors:
        schema = getUtility(IBehavior, behavior_id).interface

        if not IFormFieldProvider.providedBy(schema):
            continue

        fields.extend(getFieldsInOrder(schema))

        for fieldset in schema.queryTaggedValue(FIELDSETS_KEY, []):
            fieldset_fields.setdefault(
                fieldset.__name__, []).extend(fieldset.fields)
            ordered_fieldsets.append(fieldset.__name__)

        fieldset_fields['default'].extend(non_fieldset_fields(schema))

    ordered_fields = []

    for fieldset in ordered_fieldsets:
        ordered_fields.extend(fieldset_fields[fieldset])

    fields.sort(key=lambda field: ordered_fields.index(field[0]))

    return fields

        def _image_field_info(self):
            type_info = self.context.getTypeInfo()
            schema = type_info.lookupSchema()
            fields = getFieldsInOrder(schema)

            behavior_assignable = IBehaviorAssignable(self.context)
            if behavior_assignable:
                behaviors = behavior_assignable.enumerateBehaviors()
                for behavior in behaviors:
                    fields += getFieldsInOrder(behavior.interface)

            for fieldname, field in fields:
                img_field = getattr(self.context, fieldname, None)
                if img_field and IImage.providedBy(img_field):
                    yield (fieldname, img_field)

 def __init__(self, fti=None):
     if not fti:
         return
     sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_connection, default=None)
     if sql_connection:
         self.connection_name = sql_connection.name
     else:
         sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_table, default=None)
     if sql_connection:
         self.connection_name = sql_connection.name
     else:
         processor = SQLBaseConnectionUtility(fti)
         connection_name = processor.name
         LOG.info('Base connection utility registered as '+connection_name)
         gsm = getGlobalSiteManager()
         gsm.registerUtility(processor, ISQLBaseConnectionUtility, name=connection_name)
         self.connection_name = connection_name
     self.sql_table = fti.sql_table
     self.factory = fti.factory
     self.sql_id_column = getattr(fti, 'sql_id_column', None) and getattr(fti, 'sql_id_column', None) or 'id'
     fieldnames = {}
     for field_name, field in schema.getFieldsInOrder( fti.lookupSchema() ):
         if getattr(field, 'sql_column', None):
             sql_column = getattr(field, 'sql_column', None)
             fieldnames[field_name] = sql_column
     for line in getattr(fti, 'sql_fields_columns', []):
         fieldnames[line.split(':')[0]] = line.split(':')[1]
     self.fieldnames = fieldnames

 def __init__(self, model, **kwargs):
     BaseFieldSet.__init__(self, model, **kwargs)
     self.iface = model
     self.rebind(model)
     self._fields = OrderedDict()
     self._render_fields = OrderedDict()
     self._bound_pk = None
     for name, field in schema.getFieldsInOrder(self.iface):
         klass = field.__class__
         try:
             t = self._fields_mapping[klass]
         except KeyError:
             raise NotImplementedError('%s is not mapped to a type' % klass)
         else:
             self.append(Field(name=name, type=t))
             self._fields[name].label_text = field.title or name
             if field.description:
                 self._fields[name].set(instructions=field.description)
             if field.required:
                 self._fields[name].validators.append(validators.required)
             if klass is schema.Password:
                 self._fields[name].set(renderer=fields.PasswordFieldRenderer)
             if klass is schema.Text:
                 self._fields[name].set(renderer=fields.TextAreaFieldRenderer)
             if klass is schema.List:
                 value_type = self.iface[name].value_type
                 if isinstance(value_type, schema.Choice):
                     self._fields[name].set(options=value_type, multiple=True)
                 else:
                     self._fields[name].set(multiple=True)
             elif klass is schema.Choice:
                 self._fields[name].set(renderer=fields.SelectFieldRenderer,
                                        options=self.iface[name])

    def field(self, value):
        """
            The field information is passed to the widget after it is
            initialised.  Use this call to initialise the column
            definitions.
        """
        self._field = value
        schema = self._field.value_type.schema

        fieldmodes = {}
        if MODES_KEY:
            try:
                modes_tags = schema.getTaggedValue(MODES_KEY)
            except KeyError:
                pass
            else:
                for __, fieldname, mode in modes_tags:
                    fieldmodes[fieldname] = mode

        self.columns = []
        for name, field in getFieldsInOrder(schema):
            col = {
                'name': name,
                'label': field.title,
                'required': field.required,
                'mode': fieldmodes.get(name, None),
            }
            self.columns.append(col)

 def getFields(self):
     fields = []
     for schema_name, schema in self._getSchemas():
         for field_name, field in getFieldsInOrder(schema):
             if IChoice.providedBy(field):
                 fields.append(StringField(
                     schema_name + '.' + field.__name__,
                     required=field.required,
                     schemata='categorization',
                     widget=atapi.SelectionWidget(
                         label = field.title,
                         description = field.description,
                         ),
                     vocabulary = atapi.DisplayList([(t.value, t.title or t.token) for t in field.vocabulary]),
                     ))
             elif ISet.providedBy(field) and IChoice.providedBy(field.value_type): # XXX should be set
                 fields.append(LinesField(
                     schema_name + '.' + field.__name__,
                     required=field.required,
                     schemata='categorization',
                     widget=atapi.MultiSelectionWidget(
                         label = field.title,
                         description = field.description,
                         ),
                     vocabulary = atapi.DisplayList([(t.value, t.title or t.token) for t in field.value_type.vocabulary]),
                     ))
     return fields

def get_schema_validation_errors(action_data, schema):
    """Validate a dict against a schema.

    Return a list of basic schema validation errors (required fields,
    constraints, but doesn't check invariants yet).

    Loosely based on zope.schema.getSchemaValidationErrors, but:

    - Processes fields in schema order
    - Handles dict subscription access instead of object attribute access
    - Respects required / optional fields
    - Raises RequiredMissing instead of SchemaNotFullyImplemented
    """
    errors = []
    for name, field in getFieldsInOrder(schema):
        try:
            value = action_data[name]
        except KeyError:
            # property for the given name is not implemented
            if not field.required:
                continue
            errors.append((name, RequiredMissing(name)))
        else:
            try:
                field.bind(action_data).validate(value)
            except ValidationError as e:
                errors.append((name, e))

    # Also reject fields that are not part of the schema
    errors.extend(get_unknown_fields(action_data, schema))

    return errors

 def migrate_schema_fields(self):
     for schemata in iterSchemataForType('DashboardPODTemplate'):
         for fieldName, field in getFieldsInOrder(schemata):
             # bypass interface methods
             if not IMethod.providedBy(field):
                 # special handling for file field
                 setattr(self.new, fieldName, getattr(self.old, fieldName, None))

    def get_configured_fields(self):
        context = self.context
        tileType = queryUtility(ITileType, name=self.__name__)
        conf = self.get_tile_configuration()
        fields = getFieldsInOrder(tileType.schema)
        uuid = self.data.get('uuid', '')
        results = []
        for name, field in fields:
            image_field = INamedImageField.providedBy(field)
            data = self.data[name]
            if not ((image_field and (data or uuid)) or
                    (not image_field and data)):
                # If there's no data for this field, ignore it
                # special condition, if the field is an image field and
                # there is no uuid, then ignore it too
                continue

            if isinstance(data, RichTextValue):
                transformer = ITransformer(context, None)
                if transformer is not None:
                    content = transformer(data, 'text/x-html-safe')
            else:
                content = data

            field = {'id': name, 'content': content, 'title': field.title}

            if not self._include_updated_field(field, conf.get(name)):
                continue

            results.append(field)

        return results