def unmake_shopping_site(container, event):
    if container == event.object:
        parent = aq_parent(aq_inner(container))
        noLongerProvides(parent, IShoppingSiteRoot)
        parent.reindexObject(idxs=['object_provides'])
        message = _(u"This container is no longer a shopping site.")
        IStatusMessage(container.REQUEST).addStatusMessage(message, type='warn')

 def disable(self):
     """ See IFacetedSubtyper
     """
     if not self.can_disable:
         return self._redirect('Faceted search navigation not supported')
     noLongerProvides(self.context, IFacetedSearchMode)
     self._redirect(_('Faceted search disabled'))

 def content(self):
     try:
         return futures.resultOrSubmit(
             'futures.testing', u'placeholder',
             echo, u'testing-result-or-submit')
     finally:
         noLongerProvides(self.request, IContainsPromises)

    def upgradeObj(self, obj, path=None):
        obj._p_activate()

        if self.delRemovedObj(obj, path):
            # Deleted don't do anything else
            return

        if '__implements__' in obj.__dict__:
            self.log('Deleting __implements__ instance attributre from %r'
                     % obj)
            del obj.__dict__['__implements__']
            obj._p_changed = True

        if zodb_ifaces.IBroken.providedBy(obj):
            self.log('Removing broken interfaces from %r: %r' %
                     (obj, list(interface.directlyProvidedBy(obj))))
            interface.noLongerProvides(obj, zodb_ifaces.IBroken)

        if not self.update_catalogs:
            return
        base = aq_base(obj)

        if (
                not isinstance(obj, ZCatalog.ZCatalog) and
                callable(getattr(base, 'indexObject', None))):
            obj.indexObject()

        if callable(getattr(base, '_updateCatalog', None)):
            obj._updateCatalog(obj)

    def filter(self, components):
        """Returns a filtered list of components.

        :param components: (name, component) pairs of article components and their names
        :type components: list
        :returns: sorted (name, component) pairs of article components and their names
        :rtype: list of tuples
        """

        # prevent crashing if passing in an empty list of components
        if not components:
            return []

        # temporary provide all interfaces of the registered components
        notprovided = self.provide_all_interfaces(components)

        # get a list of all viewlets, ordered by their viewlet manager
        order = self.get_ordered_viewlets()

        # no longer provide the interfaces previously set
        for iface in notprovided:
            interface.noLongerProvides(self.context, iface)

        # compile a list of components whose viewlets are present in the list
        # of ordered viewlets
        components = [(name, comp) for name, comp in components
                                                  if comp.viewlet in order]

        # sort components based on their position in 'order'
        components = self.sort_components(components, order)
        return components

    def test_override_for_httprequest(self):
        from z3c.jbot.metaconfigure import handler
        from zope import interface
        from zope.publisher.interfaces.browser import IHTTPRequest

        class IHTTPSRequest(IHTTPRequest):
            pass

        # register handlers
        handler(
            "%s/overrides/interface" % self._tests, interface.Interface)
        handler(
            "%s/overrides/https" % self._tests, IHTTPSRequest)

        # we get the general override
        self.assertEqual(self._view.template(), self._interface_override)

        # provide the http layer
        from zope.interface import alsoProvides
        alsoProvides(self._request, IHTTPSRequest)
        self.assertEqual(self._view.template(), self._https_override)

        # revert to general override
        from zope.interface import noLongerProvides
        noLongerProvides(self._request, IHTTPSRequest)
        self.assertEqual(self._view.template(), self._interface_override)

 def disableFeature(self):
     noLongerProvides(self.context, self.feature_iface)
     self.context.portal_catalog.reindexObject(self.context,
                                               idxs=['object_provides'],
                                               update_metadata=1)
     self.context.plone_utils.addPortalMessage(self.disable_message)
     self.request.response.redirect(self.context.absolute_url())

def disable_behaviors(obj, behaviors, ifaces, reindex=True):
    """ Disable behaviors on an object.

    :param obj: The Dexterity content object to disable behaviors on.
    :type obj: object
    :param behaviors: Behaviors to be disabled on the object. This is a list of
                      dotted names of behavior schema interfaces.
    :type behaviors: list or tuple
    :param ifaces: Behavior marker interfaces belonging to the behaviors to be
                   disabled. This is a list of interface classes.
    :type ifaces: class
    :param reindex: Flag whether to reindex object after modification
    :type reindex: bool

    Use it like so:

    >>> from plone.app.event.dx.interfaces import IDXEvent
    >>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
    ...                        [IDXEvent,])
    """
    annotations = IAnnotations(obj)
    instance_behaviors = annotations.get(ANNOTATION_KEY, ())
    instance_behaviors = filter(lambda x: x not in behaviors,
                                instance_behaviors)
    annotations[ANNOTATION_KEY] = instance_behaviors

    for iface in ifaces:
        noLongerProvides(obj, iface)

    if reindex:
        obj.reindexObject(idxs=('object_provides'))

    def test_form_checked_options(self):
        login(self.portal, TEST_USER_NAME)
        alsoProvides(self.document, IPreventDelete)
        form = PreventActionsForm(self.document, self.request)
        form.updateWidgets()

        widget = form.widgets.get('delete')
        delete_widget_value = widget.items[0]
        self.assertTrue(delete_widget_value['checked'])
        widget = form.widgets.get('move_or_rename')
        move_or_rename_widget_value = widget.items[0]
        self.assertFalse(move_or_rename_widget_value['checked'])

        noLongerProvides(self.document, IPreventDelete)
        form.updateWidgets()

        widget = form.widgets.get('delete')
        delete_widget_value = widget.items[0]
        self.assertFalse(delete_widget_value['checked'])
        widget = form.widgets.get('move_or_rename')
        move_or_rename_widget_value = widget.items[0]
        self.assertFalse(move_or_rename_widget_value['checked'])

        alsoProvides(self.document, IPreventMoveOrRename)
        form.updateWidgets()

        widget = form.widgets.get('delete')
        delete_widget_value = widget.items[0]
        self.assertFalse(delete_widget_value['checked'])
        widget = form.widgets.get('move_or_rename')
        move_or_rename_widget_value = widget.items[0]
        self.assertTrue(move_or_rename_widget_value['checked'])

def mark_file(ob, event):
    if safe_hasattr(ob, 'getFile'):
        obfile = ob.getFile()
        reindex = False

        set_track_view = False
        for name, adapter in getAdapters((obfile,), ITypeRecognition):
            iface = adapter.getIface()
            if adapter.isOfType():
                if not iface.providedBy(ob):
                    alsoProvides(ob, iface)
                    reindex = True
                # if there is set an interface, I also want to switch the view
                set_track_view = True
                # ok, found the type. do not check any more.
                break
            else:
                if iface.providedBy(ob):
                    # remove the marker if the file type changed!
                    noLongerProvides(ob, iface)
                    reindex = True

        if set_track_view:
            # if at least one interface is set, switch the view.
            ob.setLayout('track_view')
        else:
            # reset the view
            ob.setLayout(ob.getDefaultLayout())
        # we need to reindex the object, because ObjectEditedEvent is fired
        # after reindexing
        if reindex:
            # TODO: just reindex object_provides?
            ob.reindexObject()

    def setData(self, interfacedata, metadata):
        """
        Sets a list of properties on a object.
        Warning: all currently set properties which are not in the
        properties-list wille be removed!

        @param object:      Plone-Object to set the properties on
        @type object:       Plone-Object
        @param properties:  list of propertes.
                            See ftw.publisher.sender.extractor
                            for format details.
        @param type:        list
        @return:            None
        """
        self.logger.info('Updating interface data (UID %s)' %
                (self.object.UID())
        )

        current_ifaces = set(self.adapted.getDirectlyProvidedNames())
        desired_ifaces = set(interfacedata)

        for iface_dotted in current_ifaces - desired_ifaces:
            iface = resolve(iface_dotted)
            noLongerProvides(self.object, iface)

        for iface_dotted in desired_ifaces - current_ifaces:
            iface = resolve(iface_dotted)
            alsoProvides(self.object, iface)

def cleanup_p4a(context):
    """ eea.facetednavigation > 4.0 doesn't depend on p4a.subtyper anymore,
    but your instance will crash if it's missing as there are persistent
    references to p4a.subtyper.interfaces.ISubtyped. After you run this script,
    you should be able to drop p4a.subtyper from your buildout.
    """
    try:
        from p4a.subtyper.interfaces import ISubtyper, ISubtyped
    except ImportError:
        logger.info('p4a.subtyper not installed. Aborting...')
        return


    ctool = getToolByName(context, 'portal_catalog')
    iface = interfaceToName(context, IFacetedNavigable)
    brains = ctool.unrestrictedSearchResults(object_provides=iface)
    for brain in brains:
        doc = brain.getObject()
        anno = queryAdapter(doc, IAnnotations)

        subtyper = getUtility(ISubtyper)
        name = getattr(subtyper.existing_type(doc), 'name', '')
        if 'faceted' not in name.lower():
            continue

        logger.info(
            'Cleanup p4a.subtyper interface and descriptor info for: %s',
            doc.absolute_url())

        noLongerProvides(doc, ISubtyped)
        anno.pop('p4a.subtyper.DescriptorInfo', None)

def disable_behaviors(obj, behaviors, ifaces):
    """ Disable behaviors on an object.

    :param obj: The Dexterity content object to disable behaviors on.
    :type obj: object
    :param behaviors: Behaviors to be disabled on the object. This is a list of
                      dotted names of behavior schema interfaces.
    :type behaviors: list
    :param ifaces: Behavior marker interfaces belonging to the behaviors to be
                   disabled. This is a list of interface classes.
    :type ifaces: class

    Use it like so:
    >>> from plone.app.event.dx.interfaces import IDXEvent
    >>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
    ...                        [IDXEvent,])

    """
    annotations = IAnnotations(obj)
    instance_behaviors = list(annotations.get(KEY, []))
    instance_behaviors = filter(lambda x: x not in behaviors,
                                instance_behaviors)
    annotations[KEY] = instance_behaviors

    for iface in ifaces:
        noLongerProvides(obj, iface)

    # TODO UNTESTED:
    obj.reindexObject(idxs=('object_provides'))

 def disable_media(self):
     """Disable the media"""
     context = self._get_real_context()
     noLongerProvides(context, IMediaActivated)
     catalog = api.portal.get_tool('portal_catalog')
     catalog.reindexObject(context)
     self._redirect(_(u'Multimedia viewlet disabled for content'))

    def set_image(self, image, contentType=None, filename=None):
        if image and not INamedBlobImage.providedBy(image):
            if hasattr(image, 'data'):
                data = image.data
            elif hasattr(image, 'read'):
                data = image.read()
            else:
                data = image
            if hasattr(image, 'filename') and not filename:
                filename = unicode(image.filename)
            elif hasattr(image, 'name') and not filename:
                filename = image.name.split('/').pop()
            if hasattr(image, 'contentType') and not contentType:
                contentType = image.contentType
            elif hasattr(image, 'encoding') and not contentType:
                contentType = image.encoding
            image = NamedBlobImage(data, contentType, unicode(filename))

        if not image and IGraphicallyCustomized.providedBy(self.context):
            noLongerProvides(self.context, IGraphicallyCustomized)
            del IAnnotations(self.context)[self._annotation]
        if image and not IGraphicallyCustomized.providedBy(self.context):
            alsoProvides(self.context, IGraphicallyCustomized)
        if image:
            IAnnotations(
                self.context)[self._annotation] = PersistentDict()
            IAnnotations(
                self.context).get(
                self._annotation)['original'] = image

 def update(self):
     form = self.request.form
     if form.get("form.button.UpdateContentTypes", None) is not None:
         types = form.get("types", None)
         if types is not None:
             if type(types).__name__ == "str":
                 types = [types]
             context = aq_inner(self.context)
             portal = getToolByName(context, "portal_url").getPortalObject()
             IPortal(portal).cart_properties.content_types = types
             catalog = getToolByName(context, "portal_catalog")
             brains = catalog(portal_type=types)
             if len(brains) != 0:
                 objects = []
                 for brain in brains:
                     obj = brain.getObject()
                     if not IPotentiallyAddableToCart.providedBy(obj):
                         alsoProvides(obj, IPotentiallyAddableToCart)
                 objects.append(obj)
             #                addables = catalog(
             #                    object_provides = IAddableToCart.__identifier__,
             #                )
             addables = [brain.getObject() for brain in catalog(object_provides=IAddableToCart.__identifier__)]
             #                objs = [ad.getObject() for ad in addables if ad in brains]
             objs = [ad.getObject() for ad in addables if ad in objects]
             if len(objs) != 0:
                 for obj in objs:
                     noLongerProvides(obj, [IAddableToCart, IPotentiallyAddableToCart])

def remove_markers(content, event):
    target = content
    if IVersion.providedBy(content):
        target = content.get_silva_object()
    for marker in event.design.markers:
        if marker.providedBy(target):
            noLongerProvides(target, marker)

 def make_not_cart_aware(self):
     context = aq_inner(self.context)
     noLongerProvides(context, ICartAware)
     parent = aq_parent(context)
     noLongerProvides(parent, ICartAware)
     url = context.absolute_url()
     return self.request.response.redirect(url)

 def enabled(self, value):
     context = removeAllProxies(self.context)
     if value:
         interface.alsoProvides(context, self.marker)
     else:
         if self.marker in interface.directlyProvidedBy(context):
             interface.noLongerProvides(context, self.marker)

 def filter(self, components, manager=None):
     """ Returns a filtered list of components
     """
     order = []
     # temporary provide all interfaces of the registered components
     notprovided = []
     for name, comp in components:
         if not comp.interface.providedBy(self.context):
             notprovided.append(comp.interface)
             interface.alsoProvides(self.context, comp.interface)
     view = component.getMultiAdapter((self.context, self.request), name=u'view')
     if manager is not None:
         manager = component.getMultiAdapter((self.context, self.request, view), VIEWLET_MANAGER_MAP.get(manager, object()), name=manager)
         viewlets = component.getAdapters((self.context, self.request, view, manager), IViewlet)
         viewlets = manager.filter(viewlets)
         viewlets = manager.sort(viewlets)
         for name, viewlet in viewlets:
             order.append(name)
     else:
         for name, iface in ORDERED_VIEWLET_MANAGERS:
             manager = component.getMultiAdapter((self.context, self.request, view), iface, name=name)
             viewlets = component.getAdapters((self.context, self.request, view, manager), IViewlet)
             viewlets = manager.filter(viewlets)
             viewlets = manager.sort(viewlets)
             for name, viewlet in viewlets:
                 order.append(name)
     # no longer provide the interfaces previously set
     for iface in notprovided:
         interface.noLongerProvides(self.context, iface)
     components = [(name, comp) for name, comp in components if comp.viewlet in order]
     components.sort(lambda x, y: cmp(order.index(x[1].viewlet), order.index(y[1].viewlet)))
     return components