Beispiel #1
0
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 in IGNORED_BEHAVIORS 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
Beispiel #2
0
    def copy_fields_dexterity(self, source, target):
        # Copy the content from the canonical fields
        try:
            fields = schema.getFieldsInOrder(
                source.getTypeInfo().lookupSchema())  # noqa
        except AttributeError as e:
            log.info("Error: %s" % "/".join(source.getPhysicalPath()))
            log.exception(e)
            return
        for key, value in fields:
            if key.lower() in SKIPPED_FIELDS_DX:
                # skip language
                log.info("Skipped %s" % key)
                continue
            self.change_content(source, target, key, value)

        # Copy the contents from behaviors
        behavior_assignable = IBehaviorAssignable(source)
        if behavior_assignable:
            behaviors = behavior_assignable.enumerateBehaviors()
            for behavior in behaviors:
                for key, value in getFieldsInOrder(behavior.interface):
                    if key.lower() in SKIPPED_FIELDS_DX:
                        # skip language
                        log.info("Skipped %s" % key)
                        continue
                    self.change_content_for_behavior(source, target, key,
                                                     behavior.interface)
Beispiel #3
0
def researh_fields_dexterity(item):
    # Get fields from schema
    fields = {
        "created": {
            "type": "datetime"
        },
        "modified": {
            "type": "datetime"
        },
        "immediately_addable_types": {
            "type": "lines"
        },
        "locally_allowed_types": {
            "type": "lines"
        },
        "constrain_types_mode": {
            "type": "integer"
        },
    }
    for field_name, field_instance in getFieldsInOrder(
            item.getTypeInfo().lookupSchema()):
        fields[field_name] = parse_field_dexterity(field_name, field_instance)

    # Get fields from behaviors
    behavior_assignable = IBehaviorAssignable(item)
    if behavior_assignable:
        behaviors = behavior_assignable.enumerateBehaviors()
        for behavior in behaviors:
            for field_name, field_instance in getFieldsInOrder(
                    behavior.interface):
                fields[field_name] = parse_field_dexterity(
                    field_name, field_instance)

    return fields
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
Beispiel #5
0
    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
Beispiel #7
0
    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)
Beispiel #8
0
    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)
Beispiel #9
0
def get_dx_schema(context):
    schema = dict(getFieldsInOrder(context.getTypeInfo().lookupSchema()))

    behavior_assignable = IBehaviorAssignable(context)
    if behavior_assignable:
        for behavior in behavior_assignable.enumerateBehaviors():
            for k, v in getFieldsInOrder(behavior.interface):
                schema[k] = v

    return schema
Beispiel #10
0
def get_dx_schema(context):
    schema = dict(getFieldsInOrder(context.getTypeInfo().lookupSchema()))

    behavior_assignable = IBehaviorAssignable(context)
    if behavior_assignable:
        for behavior in behavior_assignable.enumerateBehaviors():
            for k, v in getFieldsInOrder(behavior.interface):
                schema[k] = v

    return schema
Beispiel #11
0
    def get_field_data(self):
        from plone.dexterity.interfaces import IDexterityFTI
        from plone.behavior.interfaces import IBehaviorAssignable

        data = {}

        schema = getUtility(IDexterityFTI,
                            name=self.obj.portal_type).lookupSchema()
        for name, field in getFieldsInOrder(schema):
            data[name] = getattr(self.obj, name, None)

        behavior_assignable = IBehaviorAssignable(self.obj)
        for behavior in behavior_assignable.enumerateBehaviors():
            binst = behavior.interface(self.obj)
            bdata = {}
            for name, field in getFieldsInOrder(behavior.interface):
                bdata[name] = getattr(binst, name, None)
            data[behavior.interface.__identifier__] = bdata

        if ILayoutAware.providedBy(self.obj):
            from plone.tiles.data import ANNOTATIONS_KEY_PREFIX
            from plone.app.blocks.utils import getLayout
            from repoze.xmliter.utils import getHTMLSerializer
            from plone.app.blocks import tiles
            from plone.app.blocks import gridsystem
            from lxml.html import tostring
            tdata = {}
            annotations = IAnnotations(self.obj, {})
            for key in annotations.keys():
                if key.startswith(ANNOTATIONS_KEY_PREFIX):
                    adata = annotations[key]
                    tdata[key] = adata
            data['tile_data'] = tdata

            req = site.REQUEST
            layout = getLayout(self.obj)
            dom = getHTMLSerializer(layout)

            try:
                tiles.renderTiles(req,
                                  dom.tree,
                                  site=site,
                                  baseURL=self.obj.absolute_url() +
                                  '/layout_view')
            except TypeError:
                tiles.renderTiles(req,
                                  dom.tree,
                                  baseURL=self.obj.absolute_url() +
                                  '/layout_view')
            gridsystem.merge(req, dom.tree)

            data['rendered_layout'] = tostring(dom.tree)

        return data
Beispiel #12
0
 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_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
Beispiel #14
0
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
Beispiel #15
0
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)
Beispiel #17
0
        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 add_subscriber_in_period(self, context, period, subscriber, form,
                                 data):
        request = self.request
        subscriber.first_name = data.get("first_name")
        subscriber.last_name = data.get("last_name")
        subscriber.email = data.get("email")
        subscriber.number_of_people = int(data.get("number_of_people"))
        subscriber.reindexObject()
        period.reindexObject()

        mailer = get_actions(context).get("mailer")
        if not mailer:
            return

        extra_form = DummyFormView(context, request)
        extra_form.schema = form.schema
        extra_form.prefix = "form"
        extra_form._update()
        subscriber_fields = [x[0] for x in getFieldsInOrder(ISubscriber)]
        subscriber_fields.append("period")

        widgets = filter_widgets(extra_form.widgets, subscriber_fields)
        data = filter_fields(data, extra_form.schema, subscriber_fields)
        bodyfield = mailer.body_pt

        extra = {
            "data":
            data,
            "fields":
            OrderedDict([(i, j.title)
                         for i, j in getFieldsInOrder(extra_form.schema)], ),
            "widgets":
            widgets,
            "mailer":
            mailer,
            "body_pre":
            "",
            "body_post":
            "",
            "body_footer":
            "",
        }
        template = ZopePageTemplate(mailer.__name__)
        template.write(bodyfield)
        template = template.__of__(context)
        subscriber.all_informations = RichTextValue(
            template.pt_render(extra_context=extra), )
        subscriber.reindexObject()
Beispiel #19
0
    def fields(self):
        class o(object):
            def __init__(self, n, d, v):
                self.name = n
                self.title = d.title
                self.value = v

            @property
            def richtext(self):
                return isinstance(self.value, RichTextValue)

            @property
            def has_value(self):
                if self.richtext:
                    return not not self.value.output
                return not not self.value

        for (n, d) in getFieldsInOrder(ISyllabus):
            v = getattr(self.context, n, '')
            if n not in [
                    'semester',
            ]:
                _o = o(n, d, v)
                if _o.has_value:
                    yield _o
Beispiel #20
0
    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
Beispiel #21
0
    def dump(self, schema):
        log.info("  Dumping schema %r" % schema.__identifier__)

        fields = []
        field_dumper = FieldDumper(schema)

        for name, field in getFieldsInOrder(schema):
            dottedname = '.'.join((schema.__identifier__, field.getName()))
            if dottedname in IGNORED_FIELDS:
                log.info("  Skipping field %s" % dottedname)
                continue

            field_dump = field_dumper.dump(field)
            fields.append(field_dump)

        schema_dump = OrderedDict((
            ('name', schema.__identifier__),
            ('fields', fields),
        ))

        # Fieldsets
        fieldsets = self._get_fieldsets_for_schema(schema)
        if fieldsets:
            schema_dump['fieldsets'] = fieldsets

        return schema_dump
Beispiel #22
0
 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])
Beispiel #23
0
    def render(self, **kwargs):
        """ Render exhibit view
        """
        options = {
            'lens': self.lens,
            'id': self.__name__.replace('.', '-'),
            'extra': ""
        }

        # Add extra stuff
        extra = []
        for name, field in schema.getFieldsInOrder(IExhibitTimelineEdit):
            if name == u"lens":
                continue
            elif name == u"start" and self.start:
                extra.append('ex:start="%s"' % self.start)
                continue
            elif name == u"end" and self.end:
                extra.append('ex:end="%s"' % self.end)
                continue

            elif not name.startswith('ex_'):
                continue

            # Extra
            value = self.data.get(name, field.default)
            if value is None:
                continue

            ex_name = name.replace('ex_', 'ex:')
            extra.append('%s="%s"' % (ex_name, value))
        options['extra'] = " ".join(extra)

        return self.ex_template % options
Beispiel #24
0
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 setData(self, data, metadata):
        """Inserts the field data on self.context
        """
        for schemata in iterSchemata(self.context):
            repr = schemata(self.context)
            subdata = data.get(schemata.getName(), {})
            for name, field in schema.getFieldsInOrder(schemata):
                if name not in subdata:
                    continue
                value = subdata[name]
                value = self.unpack(name, field, value)
                if value == _marker:
                    continue

                if name == 'description' and value == '' and isinstance(
                        value, str):
                    # Prevent ValueError: Description must be unicode.
                    # Dexterity has a wrong default description which is str instead
                    # of unicode.
                    value = u''

                setattr(repr, name, value)

        if HAS_RELATIONS:
            updateRelations(self.context, None)
Beispiel #26
0
def get_field_by_name(fieldname, context):
    schemata = iterSchemata(context)
    for schema in schemata:
        fields = getFieldsInOrder(schema)
        for fn, field in fields:
            if fn == fieldname:
                return field
Beispiel #27
0
 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))
Beispiel #28
0
    def _exportNode(self):
        """Export the object as a DOM node.
        """
        node = self._getObjectNode('object')
        settings = queryAdapter(self.context, ISettings)
        for name, _field in schema.getFieldsInOrder(ISettings):
            child = self._doc.createElement('property')
            child.setAttribute('name', name)
            value = getattr(settings, name)
            if isinstance(value, (tuple, list)):
                for item in value:
                    if not value:
                        continue
                    element =  self._doc.createElement('element')
                    element.setAttribute('value', item)
                    child.appendChild(element)
            else:
                if isinstance(value, (bool, int)):
                    value = repr(value)
                value = self._doc.createTextNode(value)
                child.appendChild(value)
            node.appendChild(child)

        for child in self.context.objectValues():
            exporter = queryMultiAdapter((child, self.environ), IBody)
            node.appendChild(exporter.node)
        return node
Beispiel #29
0
def enumerate_iface_fields(iface, exclude=[], include=[]):
    for name, field in getFieldsInOrder(iface):
        if name in exclude:
            continue
        if include and name not in include:
            continue
        yield name, field
    def migrate(self, old, new):
        marker.mark(new, ILogoMarker)

        for name, field in schema.getFieldsInOrder(ILogoContent):
            migrate_simplefield(old, ILogoContent(new), name, name)

        _logger.info("Migrating Logo Content for %s" % new.absolute_url())
Beispiel #31
0
    def get_mail_body(self, fields, request, context):
        """Returns the mail-body with footer.
        """

        schema = get_fields(context)
        all_fields = [f for f in fields
                      # TODO
                      # if not (f.isLabel() or f.isFileField()) and not (getattr(self,
                      # 'showAll', True) and f.getServerSide())]
                      if not (INamedFile.providedBy(fields[f])) and not (getattr(self, 'showAll', True) and IFieldExtender(schema[f]).serverSide)
                      ]

        # which fields should we show?
        if getattr(self, 'showAll', True):
            live_fields = all_fields
        else:
            live_fields = [
                f for f in all_fields if f in getattr(self, 'showFields', ())]

        if not getattr(self, 'includeEmpties', True):
            all_fields = live_fields
            live_fields = [f for f in all_fields if fields[f]]
            for f in all_fields:
                value = fields[f]
                if value:
                    live_fields.append(f)

        #bare_fields = [schema[f] for f in live_fields]
        bare_fields = dict([(f, fields[f]) for f in live_fields])
        bodyfield = self.body_pt

        # pass both the bare_fields (fgFields only) and full fields.
        # bare_fields for compatability with older templates,
        # full fields to enable access to htmlValue
        replacer = DollarVarReplacer(fields).sub
        extra = {
            'data': bare_fields,
            'fields': dict([(i, j.title) for i, j in getFieldsInOrder(schema)]),
            'mailer': self,
            'body_pre': self.body_pre and replacer(self.body_pre),
            'body_post': self.body_post and replacer(self.body_post),
            'body_footer': self.body_footer and replacer(self.body_footer),
        }
        template = ZopePageTemplate(self.__name__)
        template.write(bodyfield)
        template = template.__of__(context)
        body = template.pt_render(extra_context=extra)

        # if isinstance(body, unicode):
            #body = body.encode("utf-8")

        #keyid = getattr(self, 'gpg_keyid', None)
        #encryption = gpg and keyid

        # if encryption:
            #bodygpg = gpg.encrypt(body, keyid)
            # if bodygpg.strip():
                #body = bodygpg

        return body
Beispiel #32
0
    def to_widget_value(self, value):
        """Just dispatch it."""
        if value is self.field.missing_value:
            return NO_VALUE

        retval = ObjectWidgetValue()
        retval.original_value = value

        registry = self.widget.request.registry
        for name, field in getFieldsInOrder(self.field.schema):
            dman = registry.getMultiAdapter((value, field), IDataManager)
            subv = dman.query()

            if subv is NO_VALUE:
                # look up default value
                subv = field.default
                # XXX: too many discriminators
                # adapter = zope.component.queryMultiAdapter(
                #    (context, self.request, self.view, field, widget),
                #    interfaces.IValue, name='default')
                # if adapter:
                #    value = adapter.get()

            widget = registry.getMultiAdapter((field, self.widget.request),
                                              IFieldWidget)
            if IFormAware.providedBy(self.widget):
                # form property required by objectwidget
                widget.form = self.widget.form
                alsoProvides(widget, IFormAware)
            converter = registry.getMultiAdapter((field, widget),
                                                 IDataConverter)
            retval[name] = converter.to_widget_value(subv)

        return retval
Beispiel #33
0
    def render(self, **kwargs):
        """ Render exhibit view
        """
        options = {
            'lens': self.lens,
            'id': self.__name__.replace('.', '-'),
            'extra': ""
        }

        # Add extra stuff
        extra = []
        for name, field in schema.getFieldsInOrder(IExhibitTileEdit):
            if name == u"lens":
                continue

            elif not name.startswith('ex_'):
                continue

            # Extra
            value = self.data.get(name, field.default)
            if value is None:
                continue

            ex_name = name.replace('ex_', 'ex:')
            extra.append('%s="%s"' % (ex_name, value))
        options['extra'] = " ".join(extra)

        return self.ex_template % options
    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
Beispiel #35
0
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
Beispiel #36
0
    def render(self, **kwargs):
        """ Render exhibit view
        """
        options = {"lens": self.lens, "id": self.__name__.replace(".", "-"), "extra": ""}

        # Add extra stuff
        extra = []
        for name, field in schema.getFieldsInOrder(IExhibitMapEdit):
            if name == u"lens":
                continue
            elif name == u"latlng" and self.latlng:
                extra.append('ex:latlng=".%s"' % self.latlng)
                continue
            elif name == u"lat" and self.lat:
                extra.append('ex:lat=".%s"' % self.lat)
                continue
            elif name == u"lng" and self.lng:
                extra.append('ex:lng=".%s"' % self.lng)
                continue
            elif not name.startswith("ex_"):
                continue

            # Extra
            value = self.data.get(name, field.default)
            if value is None:
                continue

            ex_name = name.replace("ex_", "ex:")
            extra.append('%s="%s"' % (ex_name, value))
        options["extra"] = " ".join(extra)

        return self.ex_template % options
Beispiel #37
0
 def get_taxonomies(self):
     """Return all field added by taxonomies"""
     portal_type = self.context.portal_type
     schema = getUtility(IDexterityFTI, name=portal_type).lookupSchema()
     fields = getFieldsInOrder(schema)
     taxonomies = []
     for name, field in fields:
         # categories check is a hack for Namur, do not remove it.
         if (name.startswith('taxonomy_') or 'categories' in name) \
             and field:
             if getattr(field, 'value_type', None):
                 vocabulary_name = field.value_type.vocabularyName
             else:
                 vocabulary_name = field.vocabularyName
             factory = getUtility(IVocabularyFactory, vocabulary_name)
             vocabulary = factory(api.portal.get())
             tokens = getattr(self.context, name, '')
             if not tokens:
                 continue
             if isinstance(tokens, basestring):
                 tokens = [tokens]
             categories = []
             for token in tokens:
                 if token in vocabulary.inv_data.keys():
                     cat = vocabulary.inv_data.get(token)
                     categories.append(cat[1:])
             categories.sort()
             tax = {}
             tax['name'] = field.title
             tax['id'] = name
             tax['value'] = ', '.join(categories)
             taxonomies.append(tax)
     return sort_taxonomies(taxonomies)
Beispiel #38
0
    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,
                'description': field.description,
                'required': field.required,
                'mode': fieldmodes.get(name, None),
            }
            self.columns.append(col)
Beispiel #39
0
def modifiedDexterity(obj, event):
    """ a dexterity based object was modified """
    pu = getToolByName(obj, 'portal_url', None)
    if pu is None:
        # `getObjectFromLinks` is not possible without access
        # to `portal_url`
        return
    rc = getToolByName(obj, 'reference_catalog', None)
    if rc is None:
        # `updateReferences` is not possible without access
        # to `reference_catalog`
        return

    fti = getUtility(IDexterityFTI, name=obj.portal_type)
    schema = fti.lookupSchema()
    additional_schema = getAdditionalSchemata(context=obj,
                                              portal_type=obj.portal_type)

    schemas = [i for i in additional_schema] + [schema]

    refs = set()

    for schema in schemas:
        for name, field in getFieldsInOrder(schema):
            if isinstance(field, RichText):
                # Only check for "RichText" ?
                value = getattr(schema(obj), name)
                if not value:
                    continue
                links = extractLinks(value.raw)
                refs |= getObjectsFromLinks(obj, links)

    updateReferences(IReferenceable(obj), referencedRelationship, refs)
Beispiel #40
0
 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
Beispiel #41
0
    def render(self):
        el = ElementTree.Element(ElementTree.QName(self.namespace, self.name))

        if self._value is None:
            return el

        interface = self.context.schema
        for name, field in getFieldsInOrder(interface):
            field = field.bind(self._value)
            field_value = field.get(self._value)

            # Careful this could result in elements not been displayed that
            # should be. This is tested in test_widgets but it mightened be
            # what some people think.
            if field_value == field.missing_value and \
                   not self.render_missing_values and not field.required:
                continue

            widget = zope.component.getMultiAdapter((field, self.request),
                                                    interfaces.IDAVWidget)
            widget.namespace = self.namespace
            widget.setRenderedValue(field.get(self._value))
            el.append(widget.render())

        return el
    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)
Beispiel #43
0
    def get_configured_fields(self):
        # Override this method, since we are not storing anything
        # in the fields, we just use them for configuration
        tileType = queryUtility(ITileType, name=self.__name__)
        conf = self.get_tile_configuration()

        fields = getFieldsInOrder(tileType.schema)

        results = OrderedDict()
        for name, obj in fields:
            field = {'title': obj.title}
            if name in conf:
                field_conf = conf[name]
                if ('visibility' in field_conf and field_conf['visibility'] == u'off'):
                    # If the field was configured to be invisible, then just
                    # ignore it
                    continue

                if 'htmltag' in field_conf:
                    # If this field has the capability to change its html tag
                    # render, save it here
                    field['htmltag'] = field_conf['htmltag']

                if 'imgsize' in field_conf:
                    field['scale'] = field_conf['imgsize']

                if 'size' in field_conf:
                    field['size'] = field_conf['size']

            results[name] = field

        return results
 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 modifiedDexterity(obj, event):
    """ a dexterity based object was modified """
    pu = getToolByName(obj, 'portal_url', None)
    if pu is None:
        # `getObjectFromLinks` is not possible without access
        # to `portal_url`
        return
    rc = getToolByName(obj, 'reference_catalog', None)
    if rc is None:
        # `updateReferences` is not possible without access
        # to `reference_catalog`
        return

    fti = getUtility(IDexterityFTI, name=obj.portal_type)
    fields = []

    schema = fti.lookupSchema()
    additional_schema = getAdditionalSchemata(context=obj,
                                              portal_type=obj.portal_type)

    schemas = [i for i in additional_schema] + [schema]

    refs = set()

    for schema in schemas:
        for name,field in getFieldsInOrder(schema):
            if isinstance(field, RichText):
                # Only check for "RichText" ?
                value = getattr(schema(obj), name)
                if not value:
                    continue
                links = extractLinks(value.raw)
                refs |= getObjectsFromLinks(obj, links)

    updateReferences(IReferenceable(obj), referencedRelationship, refs)
    def serialize(self, results):
        """Serialize fields of a list of Dexterity-based content type objects.

        :param results: [required] list of objects to be serialized
        :type results: list of catalog brains
        :returns: list of serialized objects
        :rtype: list of dictionaries
        """
        s = []
        for i in results:
            obj = i.getObject()
            # find out object schema to list its fields
            schema = getUtility(IDexterityFTI, name=obj.portal_type).lookupSchema()
            # initialize a dictionary with the object uri
            # XXX: should we use the UUID?
            fields = dict(uri=obj.absolute_url())
            # continue with the rest of the fields
            for name, field in getFieldsInOrder(schema):
                # 'name' could be a @property and not a real field
                if not hasattr(obj, name):
                    continue
                value = getattr(obj, name)
                fields[name] = type_cast(value, obj=obj)
            s.append(fields)
        return s
Beispiel #47
0
    def render(self, **kwargs):
        """ Render exhibit view
        """
        options = {
            'lens': self.lens,
            'id': self.__name__.replace('.', '-'),
            'extra': ""
        }

        # Add extra stuff
        extra = []
        for name, field in schema.getFieldsInOrder(IExhibitTabularEdit):
            if name == u"lens":
                continue
            elif name == u"columns":
                extra.append('ex:columns="%s"' % ", ".join(self.columns))
                extra.append('ex:columnLabels="%s"' % ", ".join(self.labels))
                extra.append('ex:columnFormats="%s"' % ", ".join(self.formats))
                continue

            elif not name.startswith('ex_'):
                continue

            # Extra
            value = self.data.get(name, field.default)
            if value is None:
                continue

            ex_name = name.replace('ex_', 'ex:')
            extra.append('%s="%s"' % (ex_name, value))
        options['extra'] = " ".join(extra)

        return self.ex_template % options
Beispiel #48
0
 def handleSubmit(self, action):
     unsorted_data, errors = self.extractData()
     if errors:
         self.status = self.formErrorsMessage
         return
     unsorted_data = self.updateServerSideData(unsorted_data)
     errors = self.processActions(unsorted_data)
     if errors:
         return self.setErrorsMessage(errors)
     data = OrderedDict(
         [x for x in getFieldsInOrder(self.schema) if x[0] in unsorted_data]
     )
     data.update(unsorted_data)
     thanksPageOverride = self.context.thanksPageOverride
     if thanksPageOverride:
         thanksPageOverrideAction = self.context.thanksPageOverrideAction
         thanksPage = get_expression(self.context, thanksPageOverride)
         if thanksPageOverrideAction == 'redirect_to':
             self.request.response.redirect(thanksPage)
         elif thanksPageOverrideAction == 'traverse_to':
             thanksPage = self.context.restrictedTraverse(
                 thanksPage.encode('utf-8'))
             thanksPage = mapply(
                 thanksPage,
                 self.request.args,
                 self.request
             ).encode('utf-8')
             self.request.response.write(thanksPage)
     else:
         # we come back to the form itself.
         # the thanks page is handled in the __call__ method
         pass
Beispiel #49
0
 def handleSubmit(self, action):
     unsorted_data, errors = self.extractData()
     if errors:
         self.status = self.formErrorsMessage
         return
     unsorted_data = self.updateServerSideData(unsorted_data)
     errors = self.processActions(unsorted_data)
     if errors:
         return self.setErrorsMessage(errors)
     data = OrderedDict(
         [x for x in getFieldsInOrder(self.schema) if x[0] in unsorted_data]
     )
     data.update(unsorted_data)
     thanksPageOverride = self.context.thanksPageOverride
     if not thanksPageOverride:
         # we come back to the form itself.
         # the thanks page is handled in the __call__ method
         return
     thanksPageOverrideAction = self.context.thanksPageOverrideAction
     thanksPage = get_expression(self.context, thanksPageOverride)
     if six.PY2 and isinstance(thanksPage, six.text_type):
         thanksPage = thanksPage.encode("utf-8")
     if thanksPageOverrideAction == "redirect_to":
         self.request.response.redirect(thanksPage)
         return
     if thanksPageOverrideAction == "traverse_to":
         thanksPage = self.context.restrictedTraverse(thanksPage)
         thanksPage = mapply(thanksPage, self.request.args, self.request)
         self.request.response.write(safe_encode(thanksPage))
Beispiel #50
0
    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
Beispiel #51
0
def create_subtask(task, data):
    subtask = createContent('opengever.task.task',
                            id=data['title'],
                            **data)
    notify(ObjectCreatedEvent(subtask))
    subtask = addContentToContainer(task, subtask,
                                    checkConstraints=True)

    for schemata in iterSchemata(subtask):
        super_repr = schemata(task)
        repr = schemata(subtask)

        for name, field in schema.getFieldsInOrder(schemata):
            if name in data:
                value = data[name]

            else:
                value = getattr(super_repr, name, None)

            setattr(repr, name, value)

    activity = TaskAddedActivity(subtask, task.REQUEST, task)
    activity.record()

    notify(ObjectModifiedEvent(subtask))
    return subtask
Beispiel #52
0
    def get_configured_fields(self):
        # Override this method, since we are not storing anything
        # in the fields, we just use them for configuration
        tileType = queryUtility(ITileType, name=self.__name__)
        conf = self.get_tile_configuration()

        fields = getFieldsInOrder(tileType.schema)

        results = []
        for name, obj in fields:
            field = {'id': name, 'title': obj.title}
            if name in conf:
                field_conf = conf[name]
                if ('visibility' in field_conf
                        and field_conf['visibility'] == u'off'):
                    # If the field was configured to be invisible, then just
                    # ignore it
                    continue

                if 'htmltag' in field_conf:
                    # If this field has the capability to change its html tag
                    # render, save it here
                    field['htmltag'] = field_conf['htmltag']

                if 'imgsize' in field_conf:
                    field['scale'] = field_conf['imgsize']

                if 'size' in field_conf:
                    field['size'] = field_conf['size']

            results.append(field)

        return results
Beispiel #53
0
    def get_configured_fields(self):
        # Override this method, since we are not storing anything
        # in the fields, we just use them for configuration
        tileType = queryUtility(ITileType, name=self.__name__)
        conf = self.get_tile_configuration()

        fields = getFieldsInOrder(tileType.schema)

        results = []
        for name, obj in fields:
            field = {"id": name, "title": obj.title}
            if name in conf:
                field_conf = conf[name]
                if "visibility" in field_conf and field_conf["visibility"] == u"off":
                    # If the field was configured to be invisible, then just
                    # ignore it
                    continue

                if "htmltag" in field_conf:
                    # If this field has the capability to change its html tag
                    # render, save it here
                    field["htmltag"] = field_conf["htmltag"]

                if "imgsize" in field_conf:
                    field["scale"] = field_conf["imgsize"]

                if "size" in field_conf:
                    field["size"] = field_conf["size"]

            results.append(field)

        return results
def set_defaults(obj):
    for schemata in iterSchemata(obj):
        for name, field in getFieldsInOrder(schemata):
            try:
                value = field.get(field.interface(obj))
                if value:
                    # field is present with a truthy value, nothing to do
                    continue
            except AttributeError:
                # Field not present, set default
                pass
            default = queryMultiAdapter(
                (obj, obj.REQUEST, None, field, None),
                IValue,
                name='default')
            if default is not None:
                default = default.get()
            if default is None:
                default = getattr(field, 'default', None)
            if default is None:
                try:
                    default = field.missing_value
                except AttributeError:
                    pass
            field.set(field.interface(obj), default)

    return obj
    def map_with_vocab(self, behavior, fieldname, value):
        """Look in the schema for a vocab and return the mapped value
        """

        if type(value) == int:
            return str(value)

        portal = self.layer['portal']
        fields = getFieldsInOrder(behavior)
        for name, field in fields:
            if name == fieldname:

                # We have different types of fields, so we have to check,
                # that we become the vocabulary
                value_type = field

                if IList.providedBy(field) or ITuple.providedBy(field):
                    value_type = field.value_type

                if IChoice.providedBy(value_type):
                    if value_type.vocabulary:
                        vocab = value_type.vocabulary(portal)

                    else:
                        vocab = getVocabularyRegistry().get(
                            portal, value_type.vocabularyName)

                    value = vocab.getTerm(value).title

        return value