def _validate(self, value):
        # XXX HACK: Can't call the super, since it'll check to
        # XXX see if we provide DictRow.
        # We're only a dict, so we can't.
        # super(DictRow, self)._validate(value)

        # Validate the dict against the schema
        # Pass 1 - ensure fields are present
        if value is NO_VALUE:
            return
        # Treat readonly fields
        for field_name in getFields(self.schema).keys():
            field = self.schema[field_name]
            if field.readonly:
                value[field_name] = field.default
        errors = []
        for field_name in getFields(self.schema).keys():
            if field_name not in value:
                errors.append(AttributeNotFoundError(field_name, self.schema))

        if errors:
            raise WrongContainedType(errors, self.__name__)

        # Pass 2 - Ensure fields are valid
        for field_name, field_type in getFields(self.schema).items():
            if IChoice.providedBy(field_type):
                # Choice must be bound before validation otherwise
                # IContextSourceBinder is not iterable in validation
                bound = field_type.bind(value)
                bound.validate(value[field_name])
            else:
                field_type.validate(value[field_name])

def get_fields(fti):
    schema = fti.lookupSchema()
    fields = getFields(schema)
    for behavior_id in fti.behaviors:
        schema = getUtility(IBehavior, behavior_id).interface
        if not IFormFieldProvider.providedBy(schema):
            continue
        fields.update(getFields(schema))

    return fields

def Portlet(name, class_=None, title='', description='',
            template=None, schema=None, **kw):
    cdict = {}
    cdict.update(kw)
    cdict['__name__'] = name
    cdict['title'] = title
    cdict['description'] = description

    if template:
        cdict['template'] = ViewPageTemplateFile(template)

    if class_ is not None:
        class_name = 'Portlet<%s:%s>'%(class_.__name__, name)
    else:
        class_name = 'Portlet<%s>'%name

    if class_ is None:
        bases = (PortletBase,)
    else:
        bases = (class_, PortletBase)

    PortletClass = type(str(class_name), bases, cdict)

    if schema is not None:
        for f_id in getFields(schema):
            if not hasattr(PortletClass, f_id):
                setattr(PortletClass, f_id, ConfigurationProperty(schema[f_id]))

        PortletClass.__schema__ = schema
        interface.classImplements(PortletClass, schema)

    return PortletClass

    def __call__(self):
        """
        """
        local_registry = self.context.get('local_registry')
        #If registry is not present, then create it
        if local_registry is None:
            enableChildRegistry(self.context, None)

        registry = queryUtility(IRegistry)
        if registry != self.context.get('local_registry'):
            return

        settings = registry.forInterface(IThemeSettings, False)
        themes = getAvailableThemes()

        if self.context.theme:
            settings.enabled = self.context.theme != DISABLE_PLONE_APP_THEMING
            for theme in themes:
                if theme.rules == self.context.theme:
                    settings.currentTheme = theme.__name__.decode()
                    settings.rules = theme.rules
                    settings.absolutePrefix = theme.absolutePrefix
                    settings.parameterExpressions = theme.parameterExpressions
                    settings.doctype = theme.doctype
        else:
            return
            fields = getFields(IThemeSettings)
            settings_fields = ('currentTheme', 'rules', 'absolutePrefix', 'parameterExpressions', 'doctype',)
            for settings_field in settings_fields:
                setattr(settings, settings_field, fields[settings_field].default)

def _potential_relations(obj):
    """Given an object return tuples of name, index, relation value.

    Returns both IRelationValue attributes as well as ITemporaryRelationValue
    attributes.

    If this is a IRelationList attribute, index will contain the index
    in the list. If it's a IRelation attribute, index will be None.
    """
    for iface in providedBy(obj).flattened():
        for name, field in getFields(iface).items():
            frel = name + '_rel'
            _rel = iface.queryTaggedValue(frel)
            if _rel is not None:
                field = _rel
                name = frel

            if IRelation.providedBy(field):
                try:
                    relation = getattr(obj, name)
                except AttributeError:
                    # can't find this relation on the object
                    continue
                yield name, None, relation
            if IRelationList.providedBy(field):
                try:
                    l = getattr(obj, name)
                except AttributeError:
                    # can't find the relation list on this object
                    continue
                if l is not None:
                    for i, relation in enumerate(l):
                        yield name, i, relation

def PreferenceGroupChecker(instance):
    """A function that generates a custom security checker.

    The attributes available in a preference group are dynamically generated
    based on the group schema and the available sub-groups. Thus, the
    permission dictionaries have to be generated at runtime and are unique for
    each preference group instance.
    """
    read_perm_dict = {}
    write_perm_dict = {}

    # Make sure that the attributes from IPreferenceGroup and IReadContainer
    # are public.
    for attrName in ('__id__', '__schema__', '__title__', '__description__',
                     'get', 'items', 'keys', 'values',
                     '__getitem__', '__contains__', '__iter__', '__len__'):
        read_perm_dict[attrName] = CheckerPublic

    # Make the attributes generated from the schema available as well.
    if instance.__schema__ is not None:
        for name in getFields(instance.__schema__):
            read_perm_dict[name] = CheckerPublic
            write_perm_dict[name] = CheckerPublic

    # Make all sub-groups available as well.
    for name in instance.keys():
        read_perm_dict[name] = CheckerPublic
        write_perm_dict[name] = CheckerPublic

    return Checker(read_perm_dict, write_perm_dict)

    async def __call__(self):
        """ data input : { 'interface': 'INTERFACE' }"""
        if not hasattr(self.request, 'site_settings'):
            return ErrorResponse(
                'BadRequest',
                _("Not in a site request"))
        data = await self.request.json()
        interface = data.get('interface', None)
        initial_values = data.get('initial_values', {})
        if interface is None:
            return ErrorResponse(
                'InvalidRequest',
                'Non existent Interface')

        registry = self.request.site_settings
        iObject = import_class(interface)
        registry.register_interface(iObject)
        config = registry.for_interface(iObject)

        # Initialize values
        # If its defined on the zope.schema default will not be overwritten
        #  you will need to PATCH
        for key, field in getFields(iObject).items():
            if key in initial_values and not getattr(config, key, False):
                # We don't have a value
                setattr(config, key, initial_values[key])

        return Response(response={}, status=201)

    def test_handleRelease(self):
        ztm = self.layer.txn
        logging.basicConfig(level=logging.CRITICAL)
        prf = ProductReleaseFinder(ztm, logging.getLogger())
        alt_file_name = 'evolution-42.0.orig.tar.bz2'
        file_path, file_name = self.create_tarball(
            'evolution-42.0.orig.tar.gz')
        file_names = set()
        prf.handleRelease('evolution', 'trunk', file_path, file_names)
        self.assertTrue(file_name in file_names)
        self.assertFalse(alt_file_name in file_names)

        # check to see that the release has been created
        evo = getUtility(IProductSet).getByName('evolution')
        trunk = evo.getSeries('trunk')
        release = trunk.getRelease('42.0')
        self.assertNotEqual(release, None)
        self.assertEqual(release.files.count(), 1)
        fileinfo = release.files[0]
        self.assertEqual(fileinfo.filetype, UpstreamFileType.CODETARBALL)
        self.assertEqual(fileinfo.libraryfile.filename, file_name)

        # verify that the fileinfo object is sane
        self.failUnless(verifyObject(IProductReleaseFile, fileinfo))
        for field in getFields(IProductReleaseFile).values():
            # XXX: BradCrittenden 2008-09-04 bug=264829:
            # Several interfaces have uploaded files as `Bytes` attributes but
            # then the values get converted to LibraryFileAlias objects.  The
            # Bytes._validate() method then fails.  As a work-around the
            # validate test is being disabled here for those fields.
            from zope.schema import Bytes
            if isinstance(field, Bytes):
                continue
            bound = field.bind(fileinfo)
            bound.validate(bound.get(fileinfo))

 def get(self):
     data = dict(self.annotations.get(self.key, {}))
     if self.tileType is not None and self.tileType.schema is not None:
         for name, field in getFields(self.tileType.schema).items():
             if name not in data:
                 data[name] = field.missing_value
     return data

    def get(self):
        # use explicitly set data (saved as annotation on the request)
        if self.key in self.annotations:
            data = dict(self.annotations[self.key])

            if self.tileType is not None and self.tileType.schema is not None:
                for name, field in getFields(self.tileType.schema).items():
                    if name not in data:
                        data[name] = field.missing_value

        # try to use a '_tiledata' parameter in the request
        elif '_tiledata' in self.tile.request.form:
            data = json.loads(self.tile.request.form['_tiledata'])

        # fall back to the copy of request.form object itself
        else:
            # If we don't have a schema, just take the request
            if self.tileType is None or self.tileType.schema is None:
                data = self.tile.request.form.copy()
            else:
                # Try to decode the form data properly if we can
                try:
                    data = decode(self.tile.request.form,
                                  self.tileType.schema, missing=True)
                except (ValueError, UnicodeDecodeError,):
                    LOGGER.exception(u'Could not convert form data to schema')
                    return self.data.copy()

        return data

def import_people(request, container, portal_type, format, data):
    dataset = get_dataset(format, data)
    attribute_map = get_attribute_map(request, dataset.headers, portal_type)

    schema = tools.get_schema_from_portal_type(portal_type)

    for ix, record in enumerate(dataset.dict):
        log.info('processing row number {}'.format(ix+1))
        try:
            values = get_attribute_values(request, record, attribute_map)

            # add None for missing values
            for field in getFields(schema).keys():
                if field not in values:
                    values[field] = None

            validate_attribute_values(schema, values)

            api.content.create(
                container=container,
                type=portal_type,
                id='',
                **values
            )
        except ContentImportError, e:
            raise ContentImportError(
                e.message, rownumber=ix+1, colname=e.colname
            )
        except Exception, e:
            log.exception('error importing people')
            raise ContentImportError(e.message, rownumber=ix+1)

def registerPreference(name, schema, klass=None,
                       title='', description='', configContext=None):
    if '.' in name:
        category, name = name.split('.', 1)
    else:
        category = ''

    PreferenceClass = preferencetype.PreferenceType(
        str(name), category, schema, klass, title, description)

    # register storage schema
    if getFields(schema):
        storage.registerSchema(
            'memphis.preferences-%s.%s'%(category, name), schema)

    # instance
    inst = PreferenceClass()

    # register preference in preferences
    def _register(preference):
        root.Preferences.addPreference(preference)

    config.addAction(
        configContext,
        discriminator = ('memphis.preferences:preference', category, name),
        callable = _register, args = (inst,))

    return inst

def getCASPlugin():
    """Return CAS Plugin within acl_users, creating one if required."""
    portal = getSite()
    acl_users = getToolByName(portal, 'acl_users')
    cas_auth_helpers = acl_users.objectValues(['CAS Auth Helper'])

    if not cas_auth_helpers:
        cas4pas = acl_users.manage_addProduct['CAS4PAS']
        cas4pas.addCASAuthHelper('cas', 'CAS Auth Helper')
        cas = acl_users['cas']

        registry = getUtility(IRegistry)
        casSettings = registry.forInterface(ICAS4PASPluginSchema)

        #Load defaults from fields
        fields = getFields(ICAS4PASPluginSchema)
        for field in fields:
            #Only set attributes the PAS plugin knows about
            if hasattr(CASAuthHelper, field):
                #Set from registry settings, which will pick up defaults
                value = getattr(casSettings, field)
                setattr(cas, field, value)

        out = StringIO()
        activatePluginInterfaces(portal, 'cas', out)
        msg = 'Created CAS plugin. %s' % out.getvalue()
        IStatusMessage(portal.REQUEST).addStatusMessage(msg, 'info')
    else:
        cas = cas_auth_helpers[0]

    return cas

    def applyTileConfigurations(self):
        conf = self.tile.get_tile_configuration()
        fields = getFields(self.tileType.schema)

        for field_name, field_conf in conf.items():
            if 'order' in field_conf and field_conf['order']:
                fields[field_name].order = int(field_conf['order'])

def extract_data_as_object(request, schema):
    obj = Object()
    data = extract_data(request, schema)
    for key, field in zschema.getFields(schema).items():
        setattr(obj, key, data[key])
    directlyProvides(obj, schema)
    return obj

    def __init__(self, oid=''):
        self.oid = oid

        # update defaults
        sch = self.__schema__
        for field in getFields(sch):
            setattr(self, field, copy.copy(sch[field].default))

    def __load__(self, datasheet):
        if self.__schema__ is not datasheet.__schema__:
            raise DatasheetException(
                "Can't load data from incompatible datasheet")

        for field in getFields(self.__schema__):
            setattr(self, field, getattr(datasheet, field))

def no_longer_searchable(iface, field_name):
    """Removes a "searchable" mark from a previously marked
    field.
    """

    if schema.getFields(iface).get(field_name) is None:
        dottedname = '.'.join((iface.__module__, iface.__name__))
        raise AttributeError(
            '{0} has no field "{1}"'.format(
                dottedname,
                field_name
            )
        )

    store = iface.queryTaggedValue(SEARCHABLE_KEY)
    if store is None:
        return False

    key = (iface, field_name, 'true')
    if key not in store:
        return False

    store.remove(key)
    iface.setTaggedValue(SEARCHABLE_KEY, store)
    return True

def evolve(context):
    root = getRootFolder(context)

    for content in findObjectsMatching(root, IRevisions.providedBy):
        content._p_activate
        schema = content.__contentclass__.__schema__

        changed = False
        if not hasattr(content, '_revisions'):
            changed = True
            content._revisions = IOBTree()
            content._revisions_length = Length(0)

        for name, field in getFields(schema).items():
            if name in content.__dict__:
                setattr(content.workingRevision, name, content.__dict__[name])
                del content.__dict__[name]
                changed = True
            elif name in ('title', 'description'):
                dc = ICMFDublinCore(content)
                val = getattr(dc, name, '')
                if val:
                    setattr(content.workingRevision, name, val)

        if changed:
            content.publishWorkingRevision()
            content._p_changed = True

    def update(self):
        self.query = self.data.get('query')
        self.sort_on = self.data.get('sort_on')

        if self.query is None or self.sort_on is None:
            # Get defaults
            tileType = queryUtility(ITileType, name=self.__name__)
            fields = getFields(tileType.schema)
            if self.query is None:
                self.query = getMultiAdapter((
                    self.context,
                    self.request,
                    None,
                    fields['query'],
                    None
                ), name='default').get()
            if self.sort_on is None:
                self.sort_on = getMultiAdapter((
                    self.context,
                    self.request,
                    None,
                    fields['sort_on'],
                    None
                ), name='default').get()

        self.limit = self.data.get('limit')
        if self.data.get('sort_reversed'):
            self.sort_order = 'reverse'
        else:
            self.sort_order = 'ascending'
        self.view_template = self.data.get('view_template')