Python interfaces.ISite类代码示例

def unregisterService(service, interface):
    """Unregister the service using the given interface.
    """
    site = service.aq_parent
    if not ISite.providedBy(site):
        raise ValueError("Service parent is not a site.")
    sm = ISite(site).getSiteManager()
    sm.unregisterUtility(service, interface)

 def getNearestSite(self):
     """See ILocationInfo
     """
     if ISite.providedBy(self.context):
         return self.context
     for parent in self.getParents():
         if ISite.providedBy(parent):
             return parent
     return self.getRoot()

 def delete_site(self):
     if not self.is_site():
         raise ValueError(_(u'Not a local site.'))
     if interfaces.IRoot.providedBy(self.context):
         raise ValueError(_(u"Can't disable local site on Silva Root."))
     sm = ISite(self.context).getSiteManager()
     if list(sm.registeredAdapters()):
         raise ValueError(_(u'Still have registered customizations.'))
     if list(sm.registeredUtilities()):
         raise ValueError(_(u'Still have registered services.'))
     disableSite(self.context)

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.location.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

      >>> try:
      ...     ensure_site(om)
      ... except TypeError:
      ...     # not supposed to do anything unless enableLocalSiteHook was found
      ...     if enableLocalSiteHook is None:
      ...         True
      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):
        if enableLocalSiteHook is not None:
            enableLocalSiteHook(context)
            setSite(context)
        else:
            raise TypeError('"%s" is not configured as an ISite' %
                            '/'.join(context.getPhysicalPath()))

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

def registerService(context, id, service, interface):
    """Set and register the service id, using interface.
    """
    if not ISite.providedBy(context.aq_base):
        site = context.Destination()
        if not ISite.providedBy(site):
            raise BadRequest("A service can only be created in a local site")
    else:
        site = context
    site._setObject(id, service)
    service = site._getOb(id)
    sm = site.getSiteManager()
    sm.registerUtility(service, interface)
    return service

def silva_session_arg_generator(parent):
    root, options = parent.next()

    if not hasattr(options, 'paths') or not len(options.paths):
        fail(u"specifiy at least one Silva root path")

    for path in options.paths:
        try:
            silva = root.unrestrictedTraverse(path)
        except KeyError:
            fail("%s is not a valid Zope path" % path)
        if not IRoot.providedBy(silva):
            fail("%s is not a valid Silva root" % path)
        if ISite.providedBy(silva):
            setSite(silva)
        else:
            setSite(None)
        setHooks()

        if hasattr(options, 'username') and options.username:
            user = zope_find_user(silva, options.username)
            newSecurityManager(None, user)

        yield silva, options

    try:
        parent.next()
    except StopIteration:
        pass
    else:
        fail(u"internal error")

 def test_enable_site(self):
     """Event handler should have configured local sitemanager."""
     mnet = self.portal['maastricht']
     self.assertTrue(ISite.providedBy(mnet))
     self.assertTrue(IObjectManagerSite.providedBy(mnet))
     self.assertNotEquals(self.portal.getSiteManager(),
                          mnet.getSiteManager())

def enableZope3Site(context):
    portal = getToolByName(context, 'portal_url').getPortalObject()
    if not ISite.providedBy(portal):
        make_objectmanager_site(portal)
        logger.info('Made the portal a Zope3 site.')
    try:
        components = portal.getSiteManager()
    except ComponentLookupError:
        next = find_next_sitemanager(portal)
        if next is None:
            next = base
        name = '/'.join(portal.getPhysicalPath())
        components = PersistentComponents(name, (next,))
        components.__parent__ = portal
        portal.setSiteManager(components)
        logger.info("Site manager '%s' added." % name)
    else:
        if components.utilities.LookupClass != FiveVerifyingAdapterLookup:
            # for CMF 2.1 beta instances
            components.__parent__ = portal
            components.utilities.LookupClass = FiveVerifyingAdapterLookup
            components.utilities._createLookup()
            components.utilities.__parent__ = components
            logger.info('LookupClass replaced.')
    # Make sure to set the new site as the new active one
    setSite(portal)

def findSite(container):
    """Return the nearest site.
    """

    if ISite.providedBy(container):
        return container
    return findNextSite(container)

    def SilvaZMIFilter(container, filter_addable=False):
        if filter_addable and not zmi_addable:
            return False
        try:
            inside_silva = interfaces.IRoot.providedBy(container.get_root())
        except AttributeError:
            inside_silva = False
        if not inside_silva:
            # Outsite of Silva, you can only add a Silva Root.
            return interfaces.IRoot.implementedBy(content)

        if interfaces.IZMIObject.implementedBy(content):
            if interfaces.ISilvaLocalService.implementedBy(content):
                # Add local service in a site.
                return ISite.providedBy(container)
            # ZMIObject are addable, but not the non-local services
            # (they must be installed).
            return not interfaces.ISilvaService.implementedBy(content)

        if interfaces.IRoot.implementedBy(content):
            # Silva Root are not addable inside Silva.
            return False

        if interfaces.IContainer.providedBy(container):
            # In a Container, you can add content.
            return interfaces.ISilvaObject.implementedBy(content)

        if interfaces.IVersionedObject.providedBy(container):
            # In a Versioned object, you can add version.
            return interfaces.IVersion.implementedBy(content)

        return False

    def validate(self, context):
        if context is self.startpoint:
            return False

        if ISite.providedBy(context):
            for obj in context.objectValues():
                if IFilesService.providedBy(obj):
                    raise StopIteration()
        return False

def activate(context):
    """Change the context to a local site.
    """
    if not ISite.providedBy(context):
        create_new_sm(context)
    sm = context.getSiteManager()
    if IFiveSiteManager is not None and IFiveSiteManager.providedBy(sm):
        clean_old_five_sm(context, create=True)
    setup_intid(context)

def closest_short_url_service(location):
    # XXX Why not use getUtility ?
    while location:
        if ISite.providedBy(location):
            service = location._getOb(SERVICE_NAME, None)
            if service is not None and \
                    IShortURLService.providedBy(service):
                return service
        location = aq_parent(location)
    return None

    def test_utility_only_in_local_site(self):
        # A service_customization can be added only in a local site.
        self.assertTrue(ISite.providedBy(self.root))

        factory = self.root.manage_addProduct['Silva']
        factory.manage_addPublication('publication', 'Publication')
        self.publication = self.root.publication

        self.assertFalse(ISite.providedBy(self.publication))
        factory = self.publication.manage_addProduct['silva.core.layout']
        self.assertRaises(BadRequest,
                          factory.manage_addCustomizationService,
                          'service_customization')

        # Now our publication become a local site.
        make_objectmanager_site(self.publication)
        self.assertTrue(ISite.providedBy(self.publication))
        factory = self.publication.manage_addProduct['silva.core.layout']
        factory.manage_addCustomizationService('service_customization')
        self.assertTrue(hasattr(self.publication, 'service_customization'))

def find_next_sitemanager(site):
    """Find the closest sitemanager that is not the specified site's
    sitemanager.
    """
    while True:
        site = get_parent(site, default=None)
        if site is None:
            return None

        if ISite.providedBy(site):
            return site.getSiteManager()