def run(self, path="", do_delete=0):
    result = list()
    result.append("setOshaMetadataExtension")
    url_tool = getToolByName(self, "portal_url")
    portal = url_tool.getPortalObject()
    obj = self
    if path:
        try:
            obj = portal.restrictedTraverse(path)
        except:
            result.append("No object found for path %s" % path)
            return "\n".join(result)

    if do_delete and ISite.providedBy(obj):
        noLongerProvides(obj, ISite)
        del obj._components
        result.append("Deleted existing site manager")
        return "\n".join(result)

    # very special and dirty hack
    # We need to kill the existing SiteManager in the European Riskobservatory
    # folder, since it contains a reference to the no longer existing
    # IEroExtender
    if obj.id in ["riskobservatory"] and ISite.providedBy(obj):
        noLongerProvides(obj, ISite)
        del obj._components
        result.append("Deleted existing site manager")

    if not ISite.providedBy(obj):
        make_objectmanager_site(obj)
        result.append("Turned %s into a local site" % obj.id)

    sitemanager = obj.getSiteManager()
    sitemanager.registerAdapter(OshaMetadataExtender, (IATEvent,), IOrderableSchemaExtender, name="event-oshametadata")

    sitemanager.registerAdapter(
        OshaMetadataExtender, (IATNewsItem,), IOrderableSchemaExtender, name="news-oshametadata"
    )

    sitemanager.registerAdapter(
        OshaMetadataExtender, (IATDocument,), IOrderableSchemaExtender, name="document-oshametadata"
    )

    sitemanager.registerAdapter(
        OshaMetadataExtender, (Iwhoswho,), IOrderableSchemaExtender, name="document-oshametadata"
    )

    sitemanager.registerAdapter(
        OshaMetadataExtender, (IPressRelease,), IOrderableSchemaExtender, name="pressrelease-oshametadata"
    )

    result.append("Registered OshaMetadataExtender as adapter on %s" % obj.id)

    return "\n".join(result)

def disable_party(context):
    if ISite.providedBy(context):
        sm = context.getSiteManager()
        name = get_name_for_site(context)
        lookup = context.get("newsletter_lookup")
        if lookup is not None:
            sm.unregisterUtility(name=name, provided=ILocalNewsletterLookup)

def setEROSchemaExtension(self, path=''):
    result = list()
    url_tool = getToolByName(self, 'portal_url')
    portal = url_tool.getPortalObject()
    obj = None
    if path:
        try:
            obj = portal.restrictedTraverse(path)
        except:
            # well, path must habe been wrong
            result.append("No object found for path %s" %path)

    if not obj:
        obj = self
        result.append("Performing actions on self (%s)" %obj.absolute_url())

    if not ISite.providedBy(obj):
        make_objectmanager_site(obj)
        result.append("Turned %s into a local site" %obj.id)
    sitemanager = obj.getSiteManager()

    sitemanager.registerAdapter(factory=TaggingSchemaExtenderERO,
                                         name=u"osha.metadata.ero")

    result.append("Registered TaggingSchemaExtenderERO as adapter on %s" %obj.id)

    return "\n".join(result)

    def update(self):
        super(PageTitle, self).update()
        context = self.context
        request = self.request
        self.titleSeparator = component.getUtility(ISEO).titleSeparator

        if not ISite.providedBy(context):
            self.notRoot = True

            site = getSite()
            tags = IHTMLTags(site, None)
            if tags is not None and tags.isAvailable() and tags.title:
                self.portal_title = tags.title
            else:
                self.portal_title = getMultiAdapter(
                    (site, request), IBreadcrumb).name

        tags = IHTMLTags(context, None)
        if tags is not None and tags.isAvailable() and tags.title:
            if not tags.appendSiteTitle:
                self.notRoot = False
            self.title = tags.title
        else:
            self.title = getMultiAdapter(
                (context, request), IBreadcrumb).name

def readme_setup(tc):
    oc_setup.fresh_skin(tc)
    if not ISite.providedBy(tc.portal):
        enableLocalSiteHook(tc.portal)
    setSite(tc.portal)
    setHooks()
    setup_mock_geocoder()

def setupVarious(context):
    portal = context.getSite()
    if not ISite.providedBy(portal):
        enableSite(portal)
    setupLanguages(portal)
    clearPortlets(portal)
    setupNavigationPortlet(portal)

def registerUtility(id, factory, ifaces, container='system'):
    site = getSite()
    if not ISite.providedBy(site):
        raise RuntimeError(_("Can't create utility."))

    sm = component.getSiteManager()

    if isinstance(container, basestring):
        if container:
            if container not in sm:
                folder = SiteManagementFolder()
                event.notify(ObjectCreatedEvent(folder))
                sm[container] = folder

            container = sm[container]
        else:
            container = sm
    elif container is None:
        container = sm

    if id not in container:
        if callable(factory):
            utility = factory()
        else:
            utility = component.createObject(factory)

        event.notify(ObjectCreatedEvent(utility))
        removeSecurityProxy(container)[id] = utility

        for iface, name in ifaces:
            sm.registerUtility(utility, iface, name)

    return container[id]

def bootStrapSubscriber(event):
    """The actual subscriber to the bootstrap IDataBaseOpenedEvent

    Boostrap a Zope3 instance given a database object This first checks if the
    root folder exists and has a site manager.  If it exists, nothing else
    is changed.  If no root folder exists, one is added.
    """

    db, connection, root, root_folder = getInformationFromEvent(event)
    root_created = False

    if root_folder is None:
        root_created = True
        # ugh... we depend on the root folder implementation
        root_folder = rootFolder()
        root[ZopePublication.root_name] = root_folder
        if not ISite.providedBy(root_folder):
            site_manager = site.LocalSiteManager(root_folder)
            root_folder.setSiteManager(site_manager)

        transaction.commit()

    connection.close()

    zope.event.notify(interfaces.DatabaseOpenedWithRoot(db))

def enableFolder(folder):
    zope.event.notify(ChildSiteWillBeCreatedEvent(folder))
    if not ISite.providedBy(folder):
        make_objectmanager_site(folder)
    # reindex so that the object_provides index is aware of our
    # new interface
    reindexObjectProvides(folder)
    zope.event.notify(ChildSiteCreatedEvent(folder))

    def isAvailable(self):
        context = self.context
        if ISite.providedBy(context) or \
                IUnremoveableContent.providedBy(context) or \
                IRenameNotAllowed.providedBy(context):
            return False

        return super(DeleteContentAction, self).isAvailable()

    def isAvailable(self):
        context = self.context

        if IPortalType.providedBy(context) or ISite.providedBy(context):
            annotation = IAnnotations(context, None)
            if annotation is not None:
                return True
        return False

    def update(self):
        if ISite.providedBy(self.context):
            self.fields = self.fields.omit('currentLocation')

        if ('fromRoot' not in self.request.form \
                and getUtility(ISearchConfig).fromRoot):
            self.request.form['%swidgets.fromRoot'%self.prefix] = ['true']

        super(SearchForm, self).update()

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

        context = self.context
        while IPagelet.providedBy(context):
            context = context.__parent__

        self.isSite = ISite.providedBy(context)
        self.contextUrl = absoluteURL(context, self.request)

    def __init__(self, content, default=None):
        while not IDraftContent.providedBy(content):
            content = content.__parent__

            if ISite.providedBy(content) or content is None:
                self.isDraft = False
                return

        self.isDraft = True

 def test_enabling_child_site(self):
     self.subtyper.change_type(
         self.portal.site1,
         u'collective.lineage.childsite')
     res = self.catalog(object_provides=IChildSite.__identifier__)
     rids = [r.getRID() for r in res]
     rid = self.catalog.getrid('/plone/site1')
     self.assertIn(rid, rids)
     self.assertTrue(ISite.providedBy(self.portal.site1))

    def findObjectsProviding(root):
        if ISite.providedBy(root):
            yield root

        values = getattr(root, "values", None)
        if callable(values):
            for subobj in values():
                for match in findObjectsProviding(subobj):
                    yield match

 def enableSite(self, portal):
     """
     Make the portal a Zope3 site and create a site manager.
     """
     if not ISite.providedBy(portal):
         make_objectmanager_site(portal)
     # The following event is primarily useful for setting the site hooks
     # during test runs.
     notify(SiteManagerCreatedEvent(portal))

    def isSelected(self, strict=False):
        intids = self.intids
        context = self.context

        if ISite.providedBy(context):
            if self.id == intids.queryId(context):
                return True
            return False

        while context is not None and not ISite.providedBy(context):
            if self.id == intids.queryId(context):
                return True
            elif strict:
                return False

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

        return False

def ensure_site(context):
    """Ensure the given context implements ISite.  The importance of
    this method is that it will ensure the given context is an ISite
    regardless of the Zope version (Zope 2.9 had a really hacked up
    SiteManager mechanism we have to account for).

      >>> from zope.app.component.interfaces import ISite, IPossibleSite
      >>> from OFS.Folder import Folder
      >>> if not IPossibleSite.implementedBy(Folder):
      ...    from zope import interface
      ...    from Products.Five.site.metaconfigure import (FiveSite,
      ...                                                  classSiteHook)
      ...    classSiteHook(Folder, FiveSite)
      ...    interface.classImplements(Folder, IPossibleSite)
      >>> om = Folder('foo')

      >>> ISite.providedBy(om)
      False

      >>> ensure_site(om)
      >>> ISite.providedBy(om)
      True

    """

    if not IPossibleSite.providedBy(context):
        if hasattr(context, 'getPhysicalPath'):
            p = '/'.join(context.getPhysicalPath())
        elif hasattr(context, 'getId'):
            p = context.getId()
        elif hasattr(context, 'id'):
            p = id
        else:
            p = str(context)

        raise TypeError('The object, "%s", is not an IPossibleSite' % p)

    if not ISite.providedBy(context):
        enableLocalSiteHook(context)
        setSite(context)

    if not ISite.providedBy(context):
        raise TypeError('Somehow trying to configure "%s" as an ISite '
                        'has failed' % '/'.join(context.getPhysicalPath()))

def disable_old_parties(newsletter):
    """
    remove old named utilities based on path
    """
    if ISite.providedBy(newsletter):
        sm = newsletter.getSiteManager()
        name = get_name_for_site_old(newsletter)
        lookup = newsletter.get("newsletter_lookup")
        if lookup is not None:
            sm.unregisterUtility(name=name, provided=ILocalNewsletterLookup)