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)

    def afterSetUp(self):
        """ Set up
        """
        setSite(self.portal)
        self.setRoles(['Manager'])
        self.portal.invokeFactory('Folder', id='folder')
        self.portal.invokeFactory('Folder', id='themes')
        self.createObject = createObject

        createObject(self.portal, 'Document', 'doc1')
        createObject(self.portal, 'File', 'video1')
        createObject(self.portal, 'Document', 'backref1')

        path = os.path.join(os.path.dirname(__file__), 'barsandtones.flv')
        zfile = open(path, 'r')
        self.portal.video1.setFile(zfile)
        zfile.close()
        # mimetype isn't set automatically
        f = self.portal.video1.getPrimaryField().getAccessor(
            self.portal.video1)()
        f.setContentType('video/x-flv')
        alsoProvides(self.portal.video1, IVideo)
        self.portal.video1.reindexObject()
        user = self.portal.portal_membership.getAuthenticatedMember()
        user.setProperties(email='[email protected]')

        # make all themes public (non deprecated)
        for theme in self.portal.portal_vocabularies.themes.objectValues():
            self.portal.portal_workflow.doActionFor(theme, 'publish')

 def runTransaction(self, attr, set_committing, *args, **kw):
     self.beginTransaction()
     max_db_retries = self.max_db_retries
     result = None
     conflict_exception = None
     for n_try in range(min(1, max_db_retries+1)):
         try:
             old_site = getSite()
             setSite(self.schooltool_app)
             callable = getattr(self.remote_task, attr)
             result = callable(*args, **kw)
             setSite(old_site)
             if set_committing:
                 try:
                     status = TaskWriteState(self.request.id)
                     status.set_committing()
                 except Exception:
                     pass # don't care really
         except ConflictError, conflict:
             # Transaction conflict, let's repeat
             conflict_exception = conflict
         except Exception:
             failure = FormattedTraceback()
             try:
                 self.abortTransaction()
             except Exception:
                 failure.append(FormattedTraceback())
             raise failure

    def test_components_unregistered_on_delete(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 = Mock(
            wraps=PersistentComponents(bases=(getGlobalSiteManager(),)))
        from zope.component.hooks import getSiteManager
        self.patch_global(getSiteManager, return_value=site_manager_mock)

        # First add the components
        ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))

        # Then remove them again
        ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))

        site_dummy = self.create_dummy(
            getSiteManager=lambda: site_manager_mock
        )
        setSite(site_dummy)
        setHooks()

        self.assertEqual(None, queryUtility(IDexterityFTI, name=portal_type))
        self.assertEqual(None, queryUtility(IFactory, name=portal_type))

def dbconfig(event):
    if conf is None:
        log.error('No product config found! Configuration will not be set')
        return
    db = Zope2.DB
    connection = db.open()
    root_folder = connection.root().get(ZopePublication.root_name, None)
    for portal_id in conf.get('portals', '').split(','):
        portal = root_folder.get(portal_id)
        if not portal:
            log.error('No such portal: ' + portal_id)
            continue
        url = conf.get('.'.join((portal_id, 'external_url')))
        if not url:
            log.error('No external_url provided for ' + portal_id)
            continue
        setSite(portal)
        registry = getUtility(IRegistry)
        try:
            recensio_settings = registry.forInterface(IRecensioSettings)
        except Exception as e:
            log.exception(e)
            log.error('Could not get recensio settings for ' + portal_id)
            continue
        if recensio_settings.external_portal_url != safe_unicode(url):
            recensio_settings.external_portal_url = safe_unicode(url)

    transaction.commit()

def global_site_manager():
    site = getSite()
    if site is not None:
        setSite()
    yield
    if site is not None:
        setSite(site)