Python hooks.setSite函数代码示例

 def getNodeText(self, jid, node):
     app = Zope2.app()
     text = ''
     try:
         portal = app.unrestrictedTraverse(self.portal_id, None)
         if portal is None:
             raise DSCException(
                 'Portal with id %s not found' % self.portal_id)
         setSite(portal)
         acl_users = getToolByName(portal, 'acl_users')
         user_id = unescapeNode(JID(jid).user)
         user = acl_users.getUserById(user_id)
         if user is None:
             raise DSCException(
                 'Invalid user %s' % user_id)
         newSecurityManager(None, user)
         ct = getToolByName(portal, 'portal_catalog')
         uid, html_id = node.split('#')
         item = ct.unrestrictedSearchResults(UID=uid)
         if not item:
             raise DSCException(
                 'Content with UID %s not found' % uid)
         item = ICollaborativelyEditable(item[0].getObject())
         text = item.getNodeTextFromHtmlID(html_id)
     finally:
         noSecurityManager()
         setSite(None)
     return text

    def get(self, path):
        if path == '/logout':
            if users.get_current_user():
                self.redirect(users.create_logout_url('/'))
            else:
                self.redirect(self.request.relative_url('/'))
            return
        setRequest(self.request)
        app = createObject('Application', self.request, self.response)
        setSite(app)
        traverser = ITraverser(app)
        stack = path.split('/')
        if stack[-1] == '':
            stack = stack[:-1]
        if stack[0] == '':
            stack = stack[1:]
        obj = traverser.traverse(self.request, self.response, stack)

        requires = getattr(obj, 'permission_required', None)
        if requires:
            user = users.get_current_user()
            if not checkPermission(obj, user, requires):
                self.redirect(users.create_login_url(self.request.uri))
                return

        if getattr(obj, 'render', None):
            self.response.out.write(obj.render())
        else:
            self.response.headers['Content-Type'] = 'text/plain'
            self.response.out.write(obj)
        getUtility(ISession).commit()
        clearRequest()

 def wrapped_func(*args, **kw):
     sm, site = getSecurityManager(), getSite()
     try:
         return func(*args, **kw)
     finally:
         setSecurityManager(sm)
         setSite(site)

    def afterSetUp(self):
        """ After setup
        """
        setSite(self.portal)

        provideAdapter(ThemeTaggableMerged)
        provideAdapter(AttributeAnnotations, provides=IAnnotations,
                       adapts=[IThemeTaggable])
        classImplements(ATNewsItem, IThemeTaggable)
        self.setRoles('Manager')

        wftool = self.portal.portal_workflow
        # create a swedish themecentre, an english feed folder and
        # a swedish feed
        self.portal.invokeFactory('Folder', id='svthemecentre')
        obj = self.portal.svthemecentre
        # turn the folder into a themecentre by calling the promote view
        # and setting a theme tag
        obj.unrestrictedTraverse('@@promote2ThemeCentre')()
        IThemeCentreSchema(obj).tags = 'climate'
        obj.setLanguage('sv')
        obj.intro.setLanguage('sv')
        wftool.doActionFor(obj, 'publish')
        obj.reindexObject()

        self.portal.invokeFactory('Folder', id='feedfolder')
        self.portal.feedfolder.setLanguage('en')
        self.portal.feedfolder.reindexObject()

        self.portal.portal_languages.addSupportedLanguage('sv')
        self.basic_auth = '%s:%s' % (default_user, default_password)

def check_root_site_manager(tool):
    """2.0.x to 2.1.0 upgrade step checker
    """
    portal = aq_parent(aq_inner(tool))
    try:
        # We have to call setSite to make sure we have a site with a proper
        # acquisition context.
        setSite(portal)
        sm = portal.getSiteManager()
        if sm.utilities.LookupClass != FiveVerifyingAdapterLookup:
            return True
    except ComponentLookupError:
        return True

    for tool_interface in _BAD_UTILITIES:
        try:
            iface = resolve(tool_interface)
        except ImportError:
            continue

        if sm.queryUtility(iface) is not None:
            return True

    for tool_id, tool_interface in _TOOL_UTILITIES:
        tool_obj = getToolByName(portal, tool_id, default=None)
        try:
            iface = resolve(tool_interface)
        except ImportError:
            continue

        if tool_obj is not None and sm.queryUtility(iface) is None:
            return True

    return False

    def test_components_registered_on_add(self):
        portal_type = u"testtype"
        fti = DexterityFTI(portal_type)
        container_dummy = self.create_dummy()
        
        # Mock the lookup of the site and the site manager at the site root
        dummy_site = self.create_dummy()
        self.mock_utility(dummy_site, ISiteRoot)
        
        site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
        getSiteManager_mock = self.mocker.replace('zope.component.hooks.getSiteManager')
        self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
        
        # We expect that no components are registered , so look for all registrations
        self.expect(site_manager_mock.registerUtility(fti, IDexterityFTI, portal_type, info='plone.dexterity.dynamic')).passthrough()
        self.expect(site_manager_mock.registerUtility(
                    mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type), 
                    IFactory, portal_type, info='plone.dexterity.dynamic')).passthrough()

        self.replay()
        
        ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
        
        site_dummy = self.create_dummy(getSiteManager = lambda: site_manager_mock)
        setSite(site_dummy)
        setHooks()
        
        self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
        self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))

    def test_components_reregistered_on_rename(self):
        portal_type = u"testtype"
        fti = DexterityFTI(portal_type)
        container_dummy = self.create_dummy()
        
        # Mock the lookup of the site and the site manager at the site root
        dummy_site = self.create_dummy()
        self.mock_utility(dummy_site, ISiteRoot)
        
        site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
        getSiteManager_mock = self.mocker.replace('zope.component.hooks.getSiteManager')
        self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1,None)
        
        # First look for unregistration of all local components
        
        self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()        
        
        # Then look for re-registration of global components
        self.expect(site_manager_mock.registerUtility(fti, IDexterityFTI, portal_type, info='plone.dexterity.dynamic')).passthrough()
        self.expect(site_manager_mock.registerUtility(
                    mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type), 
                    IFactory, portal_type, info='plone.dexterity.dynamic')).passthrough()

        self.assertEquals('string:${folder_url}/++add++testtype', fti.add_view_expr)

        self.replay()
        
        ftiRenamed(fti, ObjectMovedEvent(fti, container_dummy, fti.getId(), container_dummy, u"newtype"))
        
        site_dummy = self.create_dummy(getSiteManager = lambda: site_manager_mock)
        setSite(site_dummy)
        setHooks()
        
        self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
        self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))

def main(app):
    for site in app.objectValues('Plone Site'):
        if qiext_installed(site):
            print '== MIGRATING SITE: %s ==' % site.getId()
            setSite(site)
            migrate(site)
            app._p_jar.cacheMinimize()

    def test_registry_assignment(self):
        setRoles(self.portal, TEST_USER_ID, ['Manager'])
        self.oid = self.portal.invokeFactory('Folder', 'folder')
        setRoles(self.portal, TEST_USER_ID, ['Member'])

        folder = self.portal[self.oid]
        registry = getUtility(IRegistry)

        if not ISite.providedBy(folder):
            make_objectmanager_site(folder)

        setSite(folder)

        pc = getToolByName(folder, 'portal_catalog')
        pc.reindexObject(folder, idxs=['object_provides'])

        enableRegistry(folder)
        self.assertIn(REGISTRY_NAME, folder.objectIds())

        registry = getUtility(IRegistry)
        self.assertTrue(isinstance(registry, LineageRegistry))

        disableRegistry(folder)
        registry = getUtility(IRegistry)
        self.assertTrue(isinstance(registry, Registry))

 def site(site):
     old_site = getSite()
     setSite(site)
     try:
         yield
     finally:
         setSite(old_site)

def setUp(self):
    """Test setUp based on z3c.form.testing.setUp minus their globals.
    """
    from zope.component.testing import setUp
    setUp()
    from zope.container.testing import setUp
    setUp()
    from zope.component import hooks
    hooks.setHooks()
    from zope.traversing.testing import setUp
    setUp()

    from zope.publisher.browser import BrowserLanguages
    from zope.publisher.interfaces.http import IHTTPRequest
    from zope.i18n.interfaces import IUserPreferredLanguages
    import zope.component
    zope.component.provideAdapter(
        BrowserLanguages, [IHTTPRequest], IUserPreferredLanguages)

    from zope.site.folder import rootFolder
    site = rootFolder()
    from zope.site.site import LocalSiteManager
    from zope.component.interfaces import ISite
    if not ISite.providedBy(site):
        site.setSiteManager(LocalSiteManager(site))
    hooks.setSite(site)

def evolve(context):
    root = getRootFolder(context)
    old_site = getSite()
    app = root
    setSite(app)
    setUpLeaveSchoolDemographics(app)
    setSite(old_site)

    def upgrade(
            self, upgrade_portal=True,
            upgrade_all_profiles=True, upgrade_profiles=(), **kw):
        hooks.setSite(self.context)
        setRequest(self.context.REQUEST)
        # initialize portal_skins
        self.context.setupCurrentSkin(self.context.REQUEST)
        # setup language for plone 4: see https://docs.plone.org/manage/upgrading/version_specific_migration/p4x_to_p5x_upgrade.html#portal-languages-is-now-a-utility  # noqa
        if getattr(self.context, 'portal_languages', None):
            self.context.portal_languages(self.context, self.context.REQUEST)
        self.setup = getToolByName(self.context, 'portal_setup')
        self.log('Upgrading {0}'.format(self.context))
        # setup BrowserLayer, see: https://dev.plone.org/ticket/11673
        notify(BeforeTraverseEvent(self.context, self.context.REQUEST))

        baseline = self.setup.getBaselineContextID()
        prof_type, profile_id = baseline.split('-', 1)
        self.base_profile = profile_id
        if upgrade_portal:
            # Do the baseline profile upgrade first
            self.upgradeProfile(profile_id, **kw)

        # Upgrade extension profiles
        if upgrade_all_profiles:
            if upgrade_profiles:
                raise ValueError(
                    'upgrade_profiles conflicts with upgrade_all_profiles')
            upgrade_profiles = self.setup.listProfilesWithPendingUpgrades()
        if upgrade_profiles:
            self.upgradeExtensions(upgrade_profiles, **kw)

        self.log('Upgraded {0}'.format(self.context))

def evolve(context):
    root = getRootFolder(context)
    old_site = getSite()

    assert ISchoolToolApplication.providedBy(root)
    setSite(root)

    requireURICache(root)

    connection = context.connection

    link_oids, linkset_oids = collectOIDs(connection)

    evolveLinks(connection, link_oids)
    transaction.savepoint(optimistic=True)

    evolveLinkSets(connection, linkset_oids)
    transaction.savepoint(optimistic=True)

    addLinkCatalog(root)
    transaction.savepoint(optimistic=True)

    evolveGroupRelationships(root)
    evolveCourseRelationships(root)
    evolveResourceRelationships(root)
    evolveAdvisorRelationships(root)
    evolveSectionsRelationships(root)

    transaction.savepoint(optimistic=True)

    evolveContactRelationships(root)

    setSite(old_site)

 def setUp(self):
     portal = self.layer["portal"]
     self.portal = portal
     self.request = self.layer["request"]
     setRoles(portal, TEST_USER_ID, ["Manager"])
     setHooks()
     setSite(portal)