def afterCreate(ob):
    wf = getToolByName(ob, 'portal_workflow', None)
    if ob is not None:
        wf.notifyCreated(ob)
        catalog = getToolByName(ob, 'portal_catalog', None)
        if catalog is not None:
            catalog.reindexObject(ob)

    def updateSkinCookie(self):
        '''
        If needed, updates the skin cookie based on the member preference.
        '''
        pm = getToolByName(self, 'portal_membership')
        pu = getToolByName(self, 'portal_url')
        member = pm.getAuthenticatedMember()
        if hasattr(aq_base(member), 'portal_skin'):
            mskin = member.portal_skin
            if mskin:
                req = self.REQUEST
                cookie = req.cookies.get(self.request_varname, None)
                if cookie != mskin:
                    resp = req.RESPONSE

                    portalPath = '/' + pu.getPortalObject().absolute_url(1)

                    if not self.cookie_persistence:
                        # *Don't* make the cookie persistent!
                        resp.setCookie( self.request_varname, mskin, path=portalPath )
                    else:
                        expires = ( DateTime( 'GMT' ) + 365 ).rfc822()
                        resp.setCookie( self.request_varname
                                      , mskin
                                      , path=portalPath
                                      , expires=expires
                                      )
                    # Ensure updateSkinCookie() doesn't try again
                    # within this request.
                    req.cookies[self.request_varname] = mskin
                    req[self.request_varname] = mskin
                    return 1
        return 0

 def __call__(self, instance, *args, **kw):
     '''
     Invokes the method.
     '''
     wf = getToolByName(instance, 'portal_workflow', None)
     if wf is None or not hasattr(wf, 'wrapWorkflowMethod'):
         # No workflow tool found.
         try:
             res = apply(self._m, (instance,) + args, kw)
         except ObjectDeleted, ex:
             res = ex.getResult()
         else:
             catalog = getToolByName(instance, 'portal_catalog', None)
             if catalog is not None:
                 catalog.reindexObject(ob)

    def searchMemberDataContents( self, search_param, search_term ):
        """ Search members. This method will be deprecated soon. """
        # XXX: this method violates the rules for tools/utilities:
        # it depends on a non-utility tool
        res = []

        if search_param == 'username':
            search_param = 'id'

        mtool   = getToolByName(self, 'portal_membership')

        for member_id in self._members.keys():

            user_wrapper = mtool.getMemberById( member_id )

            if user_wrapper is not None:
                memberProperty = user_wrapper.getProperty
                searched = memberProperty( search_param, None )

                if searched is not None and searched.find(search_term) != -1:

                    res.append( { 'username': memberProperty( 'id' )
                                , 'email' : memberProperty( 'email', '' )
                                }
                            )
        return res

 def reindexObjectSecurity(self):
     """
         Reindex security-related indexes on the object
         (and its descendants).
     """
     catalog = getToolByName(self, 'portal_catalog', None)
     if catalog is not None:
         path = '/'.join(self.getPhysicalPath())
         for brain in catalog.unrestrictedSearchResults(path=path):
             brain_path = brain.getPath()
             # self is treated at the end of the method
             # Optimization in case of an indexable container
             if brain_path == path:
                 continue
             # Get the object
             if hasattr(aq_base(brain), '_unrestrictedGetObject'):
                 ob = brain._unrestrictedGetObject()
             else:
                 # BBB older Zope
                 ob = self.unrestrictedTraverse(brain_path, None)
             if ob is None:
                 # Ignore old references to deleted objects.
                 LOG('reindexObjectSecurity', PROBLEM,
                     "Cannot get %s from catalog" % brain_path)
                 continue
             s = getattr(ob, '_p_changed', 0)
             catalog.reindexObject(ob, idxs=['allowedRolesAndUsers'],
                                   update_metadata=0)
             if s is None: ob._p_deactivate()
         # Reindex the object itself, as the PathIndex only gave us
         # the descendants.
         catalog.reindexObject(self, idxs=['allowedRolesAndUsers'],
                               update_metadata=0)

    def manage_doCustomize(self, folder_path, RESPONSE=None):
        """Makes a ZODB Based clone with the same data.

        Calls _createZODBClone for the actual work.
        """

        obj = self._createZODBClone()
        
        id = obj.getId()
        fpath = tuple(split(folder_path, '/'))
        portal_skins = getToolByName(self,'portal_skins') 
        folder = portal_skins.restrictedTraverse(fpath)

        if id in folder.objectIds():
            # we cant catch the badrequest so
            # we'll that to check before hand, which makes
            # sense anyway...
            obj = folder._getOb(id)
            if RESPONSE is not None:
                RESPONSE.redirect('%s/manage_main?manage_tabs_message=%s' % (
                    obj.absolute_url(), html_quote("An object with this id already exists")
                    ))
        else:
            folder._verifyObjectPaste(obj, validate_src=0)
            folder._setObject(id, obj)

            if RESPONSE is not None:
                RESPONSE.redirect('%s/%s/manage_main' % (
                folder.absolute_url(), id))

def manage_addActionForm(self):
    """Form for adding a new CMF Action object.
    """
    profiles = []

    stool = getToolByName(self, 'portal_setup', None)
    if stool:
        for info in stool.listContextInfos():
            action_paths = []
            context = stool._getImportContext(info['id'])
            body = context.readDataFile('actions.xml')
            if body is None:
                continue
            root = parseString(body).documentElement
            for node in root.childNodes:
                if node.nodeName != 'object':
                    continue
                action_paths += _extractChildren(node)
            action_paths.sort()
            profiles.append({'id': info['id'],
                             'title': info['title'],
                             'action_paths': tuple(action_paths)})

    template = PageTemplateResource('www/addAction.zpt',
                                    globals()).__of__(self)
    return template(profiles=tuple(profiles))

    def _filteredItems( self, ids, filt ):
        """
            Apply filter, a mapping, to child objects indicated by 'ids',
            returning a sequence of ( id, obj ) tuples.
        """
        # Restrict allowed content types
        if filt is None:
            filt = {}
        else:
            # We'll modify it, work on a copy.
            filt = filt.copy()
        pt = filt.get('portal_type', [])
        if type(pt) is type(''):
            pt = [pt]
        types_tool = getToolByName(self, 'portal_types')
        allowed_types = types_tool.listContentTypes()
        if not pt:
            pt = allowed_types
        else:
            pt = [t for t in pt if t in allowed_types]
        if not pt:
            # After filtering, no types remain, so nothing should be
            # returned.
            return []
        filt['portal_type'] = pt

        query = ContentFilter(**filt)
        result = []
        append = result.append
        get = self._getOb
        for id in ids:
            obj = get( id )
            if query(obj):
                append( (id, obj) )
        return result

    def addMember(self, id, password, roles=('Member',), domains='',
                  properties=None):
        '''Creates a PortalMember and returns it. The properties argument
        can be a mapping with additional member properties. Raises an
        exception if the given id already exists, the password does not
        comply with the policy in effect, or the authenticated user is not
        allowed to grant one of the roles listed (where Member is a special
        role that can always be granted); these conditions should be
        detected before the fact so that a cleaner message can be printed.
        '''
        if not self.isMemberIdAllowed(id):
            raise 'Bad Request', 'The login name you selected is already ' \
                  'in use or is not valid. Please choose another.'
        
        failMessage = self.testPasswordValidity(password)
        if failMessage is not None:
            raise 'Bad Request', failMessage

        failMessage = self.testPropertiesValidity(properties)
        if failMessage is not None:
            raise 'Bad Request', failMessage

        # Limit the granted roles.
        # Anyone is always allowed to grant the 'Member' role.
        limitGrantedRoles(roles, self, ('Member',))

        membership = getToolByName(self, 'portal_membership')
        membership.addMember(id, password, roles, domains)
        member = membership.getMemberById(id)
        if properties is not None:
            member.setMemberProperties(properties)

        self.afterAdd(member, id, password, properties)
        return member

def createExprContext(folder, portal, object):
    '''
    An expression context provides names for TALES expressions.
    '''
    pm = getToolByName(portal, 'portal_membership')
    if object is None:
        object_url = ''
    else:
        object_url = object.absolute_url()
    if pm.isAnonymousUser():
        member = None
    else:
        member = pm.getAuthenticatedMember()
    data = {
        'object_url':   object_url,
        'folder_url':   folder.absolute_url(),
        'portal_url':   portal.absolute_url(),
        'object':       object,
        'folder':       folder,
        'portal':       portal,
        'nothing':      None,
        'request':      getattr( object, 'REQUEST', None ),
        'modules':      SecureModuleImporter,
        'member':       member,
        }
    return getEngine().getContext(data)

 def getTypeInfo(self):
     """ Get the TypeInformation object specified by the portal type.
     """
     tool = getToolByName(self, 'portal_types', None)
     if tool is None:
         return None
     return tool.getTypeInfo(self)  # Can return None.

 def _uuid_unregister(self, reference_manager=None):
     """remove all references"""
     if not reference_manager:
         reference_manager = getToolByName(self, REFERENCE_MANAGER, None)
         
     if reference_manager is not None:
         reference_manager.unregisterObject(self)

    def searchMembers( self, search_param, search_term ):
        """ Search the membership """
        # XXX: this method violates the rules for tools/utilities:
        # it depends on a non-utility tool
        md = getToolByName( self, 'portal_memberdata' )

        return md.searchMemberData( search_param, search_term )

    def reindexObjectSecurity(self, skip_self=False):
        """Reindex security-related indexes on the object.

        Recurses in the children to reindex them too.

        If skip_self is True, only the children will be reindexed. This
        is a useful optimization if the object itself has just been
        fully reindexed, as there's no need to reindex its security twice.
        """
        catalog = getToolByName(self, 'portal_catalog', None)
        if catalog is None:
            return
        path = '/'.join(self.getPhysicalPath())
        for brain in catalog.unrestrictedSearchResults(path=path):
            brain_path = brain.getPath()
            if brain_path == path and skip_self:
                continue
            # Get the object
            if hasattr(aq_base(brain), '_unrestrictedGetObject'):
                ob = brain._unrestrictedGetObject()
            else:
                # BBB: Zope 2.7
                ob = self.unrestrictedTraverse(brain_path, None)
            if ob is None:
                # BBB: Ignore old references to deleted objects.
                # Can happen only in Zope 2.7, or when using
                # catalog-getObject-raises off in Zope 2.8
                LOG('reindexObjectSecurity', PROBLEM,
                    "Cannot get %s from catalog" % brain_path)
                continue
            # Recatalog with the same catalog uid.
            s = getattr(ob, '_p_changed', 0)
            catalog.reindexObject(ob, idxs=self._cmf_security_indexes,
                                  update_metadata=0, uid=brain_path)
            if s is None: ob._p_deactivate()

 def reindexObjectSecurity(self, skip_self=False):
     """
         Reindex security-related indexes on the object
         (and its descendants).
     """
     catalog = getToolByName(self, 'portal_catalog', None)
     if catalog is not None:
         path = '/'.join(self.getPhysicalPath())
         for brain in catalog.unrestrictedSearchResults(path=path):
             brain_path = brain.getPath()
             # self is treated at the end of the method
             # Optimization in case of an indexable container
             if brain_path == path:
                 continue
             # Get the object
             ob = brain._unrestrictedGetObject()
             if ob is None:
                 # Ignore old references to deleted objects.
                 LOG('reindexObjectSecurity', PROBLEM,
                     "Cannot get %s from catalog" % brain_path)
                 continue
             s = getattr(ob, '_p_changed', 0)
             catalog.reindexObject(ob, idxs=self._cmf_security_indexes,
                                   update_metadata=0)
             if s is None: ob._p_deactivate()
         # Reindex the object itself in here if not explicitly
         # asked to not to
         if not skip_self:
             catalog.reindexObject(self, idxs=self._cmf_security_indexes,
                                   update_metadata=0)

    def getDefaultChainFor(self, ob):
        types_tool = getToolByName( self, 'portal_types', None )
        if ( types_tool is not None
            and types_tool.getTypeInfo( ob ) is not None ):
            return self._default_chain

        return ()

 def invokeFactory(self, type_name, id, RESPONSE=None, *args, **kw):
     '''
     Invokes the portal_types tool.
     '''
     pt = getToolByName(self, 'portal_types')
     apply(pt.constructContent, (type_name, self, id, RESPONSE) + args,
           kw)

    def searchMemberData(self, search_param, search_term, attributes=()):
        """ Search members. """
        res = []

        if not search_param:
            return res

        membership = getToolByName(self, 'portal_membership')

        if len(attributes) == 0:
            attributes = ('id', 'email')

        if search_param == 'username':
            search_param = 'id'

        for user_id in self._members.keys():
            u = membership.getMemberById(user_id)

            if u is not None:
                memberProperty = u.getProperty
                searched = memberProperty(search_param, None)

                if searched is not None and searched.find(search_term) != -1:
                    user_data = {}

                    for desired in attributes:
                        if desired == 'id':
                            user_data['username'] = memberProperty(desired, '')
                        else:
                            user_data[desired] = memberProperty(desired, '')

                    res.append(user_data)

        return res

def _getProfileInfo(dispatcher, meta_type):
    profiles = []
    stool = getToolByName(dispatcher, 'portal_setup', None)
    if stool:
        for info in stool.listContextInfos():
            type_ids = []
            context = stool._getImportContext(info['id'])
            filenames = context.listDirectory('types')
            if filenames is None:
                continue
            for filename in filenames:
                body = context.readDataFile(filename, subdir='types')
                if body is None:
                    continue
                root = parseString(body).documentElement
                if root.getAttribute('meta_type') == meta_type:
                    type_id = root.getAttribute('name')
                    type_ids.append(type_id)
            if not type_ids:
                continue
            type_ids.sort()
            profiles.append({'id': info['id'],
                             'title': info['title'],
                             'type_ids': tuple(type_ids)})
    return tuple(profiles)

 def getBRefs(self, relationship=None):
     """get all the back referenced objects for this object"""
     tool = getToolByName(self, REFERENCE_MANAGER)
     refs = tool.getBackReferences(self, relationship)
     if refs:
         return [ref.getSourceObject() for ref in refs]
     return []