Python schema.getFieldNamesInOrder函数代码示例

def decode(dump, target=None, target_class=None):
    data = simplejson.loads(dump)
    registry = get_current_registry()

    fields = {}

    # collect all target's fields by their name
    if target:
        for interface in target.__provides__.interfaces():
            for name in getFieldNamesInOrder(interface):
                fields[name] = interface[name]

    # collect all target_class' fields by their name
    if target_class:
        for interface in target_class.__implemented__.interfaces():
            for name in getFieldNamesInOrder(interface):
                fields[name] = interface[name]

    values = {}
    for k, v in data.iteritems():
        # convert dictionary keys from unicode to str
        if isinstance(k, unicode):
            k = k.encode("utf-8")
        # convert dictionary values to proper field values
        if k in fields:
            v = registry.queryMultiAdapter(
                (fields[k], v), IFieldValue, default=v)
        values[k] = v

    return values

    def _set_default_configuration(self):
        defaults = {}
        tile_type = getUtility(ITileType, name=self.tile.__name__)
        fields = getFieldNamesInOrder(tile_type.schema)

        for name, field in getFieldsInOrder(tile_type.schema):
            order = unicode(fields.index(name))
            # default configuration attributes for all fields
            defaults[name] = {"order": order, "visibility": u"on"}
            if name == "css_class":
                # css_class, set default
                defaults[name] = field.default
            if ITextLine.providedBy(field):
                # field is TextLine, we should add 'htmltag'
                defaults[name]["htmltag"] = u"h2"
            elif INamedBlobImageField.providedBy(field):
                # field is an image, we should add 'position' and 'imgsize'
                defaults[name]["position"] = u"left"
                defaults[name]["imgsize"] = u"mini 200:200"
            elif IInt.providedBy(field):
                defaults[name][name] = field.default
            elif IDatetime.providedBy(field):
                # field is Datetime, we should add 'format'
                defaults[name]["format"] = "datetime"

        return defaults

def format_street_address(item, formatter):
    address_parts = []
    for attribute in getFieldNamesInOrder(IAddress):
        address_part = getattr(item, attribute, None)
        if address_part is not None:
            address_parts.append(address_part)
    return ", ".join(address_parts)

    def _normalize(self):
        if self.for_ is None:
            self.for_ = self.schema

        if self.class_ is None:
            self.bases = (self.view,)
        else:
            self.bases = (self.class_, self.view)

        if self.template is not None:
            self.template = os.path.abspath(str(self.template))
            if not os.path.isfile(self.template):
                raise ConfigurationError("No such file", self.template)
        else:
            self.template = self.default_template

        self.names = getFieldNamesInOrder(self.schema)

        if self.fields:
            for name in self.fields:
                if name not in self.names:
                    raise ValueError("Field name is not in schema",
                                     name, self.schema)
        else:
            self.fields = self.names

 def __init__(self, context, request=None):
     self.context = context
     self.request = request
     self.datasets = []
     self.datapoints = {}
     self.schema = IFormDefinition(self.context).schema
     self.fieldnames = getFieldNamesInOrder(self.schema)

 def __init__(self, schema, **kwargs):
     if IInterface.providedBy(schema):
         self.identifier = schema.__identifier__
     else:
         self.identifier = str(schema)
     for name in getFieldNamesInOrder(interfaces.IFlavor):
         if name in kwargs:
             setattr(self, name, kwargs.get(name))

 def __init__(self, context, request=None):
     ## context should be context of API view, not API view itself
     self.context = context
     self.__parent__ = context  # may be re-parented by API to view
     self.request = getRequest() if request is None else request
     self.definition = IFormDefinition(self.context)
     self._schema = self.definition.schema
     self._fieldnames = getFieldNamesInOrder(self._schema)

def getFields(context):
    domain_model = proxy.removeSecurityProxy(context.domain_model)
    domain_interface = queryModelInterface(domain_model)
    field_names = schema.getFieldNamesInOrder(domain_interface)
    for f in field_names:
        field = domain_interface[f]
        if isinstance(field, (schema.Choice, schema.Object, schema.List, schema.Tuple, schema.Bytes)):
            continue
        yield field

def get_unknown_fields(action_data, schema):
    """Return an error list of unknown fields that are not part of the schema.
    """
    errors = []
    known_field_names = getFieldNamesInOrder(schema)
    for key in action_data:
        if key not in known_field_names:
            errors.append((key, UnknownField(key)))
    return errors

 def available_fields(self):
     fields = []
     names = [
         name for name in getFieldNamesInOrder(IListingSearchTile)
         if name.startswith('form_')
     ]
     for name in names:
         if self.data.get(name, False):
             fields.append(name.split('form_')[1])
     return fields

def values(obj):
    registry = get_current_registry()
    values = {}
    for interface in obj.__provides__.interfaces():
        for name in getFieldNamesInOrder(interface):
            field = interface[name]
            bound = field.bind(obj)
            value = bound.get(obj)
            values[name] = registry.queryMultiAdapter(
                (field, value), IJSONValue, default=value)
    return values

 def __init__(self, context, request):
     self.context = context
     self.request = request
     self.portal = getSite()
     self.definition = IFormDefinition(self.context)
     self.series = context.__parent__  # assumes series <>--- form
     self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
     self.seriesinfo = dict(
         [(k, v) for k, v in self.series.__dict__.items()
          if v is not None and k in getFieldNamesInOrder(IFormSeries)]
         )

    def __init__(cls, name, bases, dct, map_kind=True):
        """Initializes a class that might implement interfaces"""

        registry = get_current_registry()
        implements = getattr(cls, "__implements_advice_data__", None)
        for interface in (implements and implements[0] or ()):
            for name in schema.getFieldNamesInOrder(interface):
                field = interface[name]
                setattr(cls, name, registry.getAdapter(field, IProperty))
                dct.update({name: getattr(cls, name)})
        super(SchemaPropertiedClass, cls).__init__(name, bases, dct, map_kind)

    def testSA2ZS(self):

        iusers = transmute(users)
        self.assertEqual(tuple(schema.getFieldNamesInOrder(iusers)), ("user_id", "user_name"))

        fields = dict(schema.getFieldsInOrder(iusers))
        # assert types and constraints
        self.assertTrue(isinstance(fields["user_id"], schema.Int))
        self.assertTrue(fields["user_id"].required)
        self.assertTrue(isinstance(fields["user_name"], schema.TextLine))
        self.assertEqual(fields["user_name"].max_length, 40)
        self.assertEqual(fields["user_name"].default, u"hello world")

    def test_syncSchema_overwrite(self):
        class ISource(Interface):
            one = schema.TextLine(title=u"A")
            two = schema.Int(title=u"B")

        class IDest(Interface):
            one = schema.TextLine(title=u"C")
            three = schema.Int(title=u"D")

        ISource.setTaggedValue("tag1", "tag one")
        ISource.setTaggedValue("tag2", "tag two")
        IDest.setTaggedValue("tag1", "first tag")

        utils.syncSchema(ISource, IDest, overwrite=True)

        self.assertEqual(u"A", IDest["one"].title)

        self.assertEqual(["one", "two"], getFieldNamesInOrder(ISource))
        self.assertEqual(["one", "two"], getFieldNamesInOrder(IDest))

        self.assertEqual("tag one", IDest.getTaggedValue("tag1"))
        self.assertEqual("tag two", IDest.getTaggedValue("tag2"))