def commentRemoved(comment, ev):
    comment = removeAllProxies(comment)
    catalog = removeAllProxies(getCatalog())
    try:
        catalog.unindex_doc(getUtility(IIntIds).getId(comment))
    except KeyError:
        pass

    def testTraverseNameView(self):
        pub = self.klass(self.db)

        class I(Interface):
            pass

        class C(object):
            implements(I)

        ob = C()

        class V(object):
            def __init__(self, context, request):
                pass

            implements(ISOAPPresentation)

        # Register the simple traverser so we can traverse without @@
        from z3c.soap.interfaces import ISOAPPublisher, ISOAPRequest
        from zope.app.publication.traversers import SimpleComponentTraverser

        ztapi.provideView(Interface, ISOAPRequest, ISOAPPublisher, "", SimpleComponentTraverser)

        r = self._createRequest("/@@spam", pub)
        ztapi.provideView(I, ISOAPRequest, Interface, "spam", V)
        ob2 = pub.traverseName(r, ob, "@@spam")
        self.assertEqual(removeAllProxies(ob2).__class__, V)

        ob2 = pub.traverseName(r, ob, "spam")
        self.assertEqual(removeAllProxies(ob2).__class__, V)

    def testTraverseNameView(self):
        pub = self.klass(self.db)

        class I(Interface):
            pass

        class C(object):
            implements(I)

        ob = C()

        class V(object):
            def __init__(self, context, request):
                pass
            implements(IXMLRPCView)


        # Register the simple traverser so we can traverse without @@
        component.provideAdapter(SimpleComponentTraverser,
                                 (Interface, IXMLRPCRequest),
                                 IXMLRPCPublisher)

        r = self._createRequest('/@@spam', pub)
        component.provideAdapter(V, (I, IXMLRPCRequest), Interface,
                                 name='spam')
        ob2 = pub.traverseName(r, ob, '@@spam')
        self.assertEqual(removeAllProxies(ob2).__class__, V)

        ob2 = pub.traverseName(r, ob, 'spam')
        self.assertEqual(removeAllProxies(ob2).__class__, V)

    def retract(self, principal=None):
        if principal is None:
            principal = getPrincipal()

        if not self.isRetractable(principal):
            raise DraftException('Cannot retract content.')

        container = queryMultiAdapter((principal, self), IDraftContainer)
        if container is None:
            raise DraftException('Cannot find draft container.')

        content = self.context

        origName = content.__name__
        oldContainer = content.__parent__

        newName = INameChooser(container).chooseName(u'', content)

        container[newName] = removeAllProxies(content)
        del removeAllProxies(oldContainer)[origName]

        draft = container[newName]
        event.notify(ObjectRetractedEvent(content, draft))

        return draft

 def generateMessageId(self, post, salt=None):
     ids = getUtility(IIntIds)
     post = ids.getId(removeAllProxies(post))
     if salt:
         if not isinstance(salt, basestring):
             salt = str(ids.getId(removeAllProxies(salt)))
         return '<%s.%[email protected]>'%(post, salt)
     else:
         return '<%[email protected]>'%post

def getMailInDestination(context):
    annotation = IAnnotations(removeAllProxies(context))

    destination = annotation.get(KEY)
    if destination is None:
        destination = MailInAwareDestination(removeAllProxies(context))
        annotation[KEY] = destination

    return destination

    def __call__(self):
        context = self.context
        removeAllProxies(context)._v_currentRevision = -1

        rendered = super(WorkingRevision, self).__call__()

        removeAllProxies(context)._v_currentRevision = None

        return rendered

    def getContent(self):
        content = self.wizard.getContent()
        data = removeAllProxies(content.getFieldData())

        for schema in (removeAllProxies(content).__schema__, IField):
            for name in getFieldNames(schema):
                field = schema[name].bind(content)
                data[name] = field.get(content)

        return data

    def __call__(self):
        revid = int(self.context.__name__)
        content = self.context.__parent__.__parent__

        if checkPermission('zojax.ModifyContent', content):
            removeAllProxies(content).setRevision(revid)
            IStatusMessage(self.request).add(
                _('Revision has been activated.'))

        self.redirect('../')

    def install(self):
        ws = self.space.get(self.name)

        if not IMessagesWorkspace.providedBy(ws):
            ws = MessagesWorkspace(self.space.principalId)
            event.notify(ObjectCreatedEvent(ws))
            removeAllProxies(self.space)[self.name] = ws
            ws.__name__ = self.name
            ws.__parent__ = removeAllProxies(self.space)

        return ws

    def __init__(self, record, default=None):
        values = []
        ids = getUtility(IIntIds)

        context = removeAllProxies(record.object)
        while context is not None:
            values.append(ids.queryId(context))

            context = removeAllProxies(
                getattr(context, '__parent__', None))

        self.value = values

    def search(self, object=None, contexts=(),
               sort_on='date', sort_order='reverse',
               noSecurityChecks=False, **kw):

        ids = getUtility(IIntIds)

        query = dict(kw)

        # records for object
        if type(object) is not type({}) and object is not None:
            oid = ids.queryId(removeAllProxies(object))
            if oid is None:
                return ResultSet(IFBTree(), getUtility(IActivity))

            query['object'] = {'any_of': (oid,)}

        # context
        if not contexts:
            contexts = (getSite(),)

        c = []
        for context in contexts:
            id = ids.queryId(removeAllProxies(context))
            if id is not None:
                c.append(id)

        query['contexts'] = {'any_of': c}

        # security
        if not noSecurityChecks:
            request = getRequest()
            if request is not None:
                users = listAllowedRoles(request.principal, getSite())
                if 'zope.Anonymous' not in users:
                    users.append('zope.Anonymous')

                query['allowedUsers'] = {'any_of': users}

        # apply searh terms
        results = self.apply(query)
        if results is None:
            results = IFBTree()

        # sort result by index
        if sort_on and sort_on in self:
            sortable = ISortable(self[sort_on], None)
            if sortable is not None:
                results = sortable.sort(results)

        if sort_order == 'reverse':
            return ReverseResultSet(results, getUtility(IActivity))
        else:
            return ResultSet(results, getUtility(IActivity))

    def completeTask(self):
        results = getUtility(ICatalog).searchResults(
            type={'any_of': ('project.task',),},
            projectTaskState = {'any_of': (1,)},
            projectTaskMilestone = {'any_of': (getUtility(IIntIds).getId(self),)},
            searchContext = self.__parent__.__parent__)

        for task in results:
            removeAllProxies(task).completeTask()
            event.notify(ObjectModifiedEvent(task))

        self.state = 2
        event.notify(StateChangedEvent(self, 2))

    def search(self, content=None,
               contexts=(), sort_on='date', sort_order='reverse', types=(), approved=()):
        ids = getUtility(IIntIds)
        indexes = list(self.values())

        query = {}

        # comments for content
        if content:
            query['content'] = {'any_of':(ids.getId(removeAllProxies(content)),)}

        # context
        if contexts:
            c = []
            for context in contexts:
                id = ids.queryId(removeAllProxies(context))
                if id is not None:
                    c.append(id)

            query['contexts'] = {'any_of': c}

        # content type
        if types:
            query['type'] = {'any_of': types}

        # security
        users = listAllowedRoles(getRequest().principal, getSite())
        if 'zope.Anonymous' not in users:
            users.append('zope.Anonymous')

        query['access'] = {'any_of': users}

        # comments approved
        if approved:
            query['approved'] = {'any_of': approved}

        # apply searh terms
        results = self.apply(query)
        if results is None:
            results = IFBTree()

        # sort result by index
        if sort_on and sort_on in self:
            sortable = ISortable(self[sort_on], None)
            if sortable is not None:
                results = sortable.sort(results)

        if sort_order == 'reverse':
            return ReverseResultSet(results, ids)
        else:
            return ResultSet(results, ids)

    def publishTraverse(self, request, name):
        view = queryMultiAdapter((self.context, request), name=name)
        if view is not None:
            return view

        tasks = self.context.__parent__.__parent__.get('tasks')
        if tasks is not None:
            task = tasks.get(name)
            if task is not None:
                id = getUtility(IIntIds).getId(removeAllProxies(self.context))
                if task.milestone == id:
                    return LocationProxy(
                        removeAllProxies(task), self.context, name)

        raise NotFound(self.context, name, request)

    def handleSend(self, action):
        request = self.request
        data, errors = self.extractData()

        if errors:
            IStatusMessage(request).add(self.formErrorsMessage, 'error')
        else:
            message = data['message']
            members = self.context.members
            getPrincipal = getUtility(IAuthentication).getPrincipal
            invitations = getUtility(IInvitations)
            group = removeAllProxies(self.context)

            for pid in request.get('principal.users', ()):
                try:
                    principal = getPrincipal(pid)
                except PrincipalLookupError:
                    continue

                if not invitations.catalog.search(
                    group, type = {'any_of': ('invitation.member',)},
                    principal = {'any_of': (pid,)}):
                    removeSecurityProxy(members).invite(pid, message)

            IStatusMessage(request).add(_(u'Invitations have been sent.'))
            self.redirect('.')

def taskAttributesConfig(context):
    while not IProject.providedBy(context):
        context = context.__parent__
        if context is None:
            return

    return removeAllProxies(context.get('tasks'))

def milestoneModified(milestone, ev):
    if milestone.state == 1:
        name = u'project.milestone.active'
    else:
        name = u'project.milestone.completed'

    IObjectPermissionsMapsManager(removeAllProxies(milestone)).set((name,))

    def update(self):
        super(AttachView, self).update()

        id = getUtility(IIntIds).queryId(removeAllProxies(self.context))

        self.url = '%s/@@content.attachment/%s/'%(
            absoluteURL(getSite(), self.request), id)

    def _prepareViews(self):
        views = {IBrowserRequest: [], IXMLRPCRequest: [], IHTTPRequest: [],
                 IFTPRequest: [], None: []}
        type_map = {IBrowserRequest: 'Browser', IXMLRPCRequest: 'XMLRPC',
                    IHTTPRequest: 'HTTP', IFTPRequest: 'FTP', None: 'Other'}
        level_map = {'generic': component.GENERIC_INTERFACE_LEVEL,
                     'extended': component.EXTENDED_INTERFACE_LEVEL,
                     'specific': component.SPECIFIC_INTERFACE_LEVEL}

        iface = removeAllProxies(self.context)

        for reg in presentation.getViews(iface):
            type = presentation.getPresentationType(reg.required[-1])

            views[(type in views) and type or None].append(reg)


        sort_function = lambda x, y: cmp(x['name'], y['name'])

        for type, sel_views in views.items():
            for level, qualifier in level_map.items():
                regs = tuple(component.filterAdapterRegistrations(
                    sel_views, iface, level=qualifier))
                infos = [presentation.getViewInfoDictionary(reg)
                         for reg in regs]
                infos.sort()
                setattr(self, level+type_map[type]+'Views', infos)