def getDestinationFolder(stats_folder): portal = api.portal.get() setSite(portal) # Create 'stats_folder' folder if not exists if portal.get(stats_folder) is None: makeFolder(portal, stats_folder) portal = portal.get(stats_folder) today = datetime.now() context = aq_inner(portal) tool = getToolByName(context, 'translation_service') month = tool.translate(today.strftime("%B"), 'ulearn', context=context).encode() month = month.lower() year = today.strftime("%G") # Create year folder and month folder if not exists if portal.get(year) is None: makeFolder(portal, year) portal = portal.get(year) makeFolder(portal, month) # Create month folder if not exists else: portal = portal.get(year) if portal.get(month) is None: makeFolder(portal, month) portal = portal.get(month) return portal
def ploneSite(db=None, connection=None, environ=None): """Context manager for working with the Plone portal during layer setup:: with ploneSite() as portal: ... This is based on the ``z2.zopeApp()`` context manager. See the module ``plone.testing.z2`` for details. Do not use this in a test. Use the 'portal' resource from the PloneFixture layer instead! Pass a ZODB handle as ``db`` to use a specificdatabase. Alternatively, pass an open connection as ``connection`` (the connection will not be closed). """ from zope.site.hooks import setSite, getSite, setHooks setHooks() site = getSite() with z2.zopeApp(db, connection, environ) as app: portal = app[PLONE_SITE_ID] setSite(portal) login(portal, TEST_USER_NAME) try: yield portal finally: logout() if site is not portal: setSite(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 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 _get_site(app, args): # Zope.Startup.zopectl.ZopeCmd.run_entrypoint promises to pass the entry # point's name as the first argument and any further arguments after that, # but that does not work with plone.recipe.zope2instance. Using positional # arguments therefore is unreliable - resolve to using a flag. parser = argparse.ArgumentParser() parser.add_argument( '--plonesite', help='Name of the Plone site', default=None ) namespace, unused = parser.parse_known_args(args) name = namespace.plonesite if name is not None: if name not in app: logger.error("Specified site '%s' not found in database." % name) sys.exit(1) else: from Products.CMFPlone.Portal import PloneSite for k, v in app.items(): if isinstance(v, PloneSite): name = k break if not name: logger.error("No Plone site found in database root.") sys.exit(1) site = getattr(app, name) setHooks() setSite(site) return site
def _setup(app, site=None): """Set up our environment. Create a request, log in as admin and set the traversal hooks on the site. """ from Testing import makerequest # Do not import this at the module level! app = makerequest.makerequest(app) # Login as admin admin = app.acl_users.getUserById('admin') if admin is None: logger.error("No user called `admin` found in the database. " "Use --rootpassword to create one.") sys.exit(1) # Wrap the admin in the right context; from inside the site if we have one if site is not None: admin = admin.__of__(site.acl_users) site = app[site.getId()] else: admin = admin.__of__(app.acl_users) newSecurityManager(None, admin) # Set up local site manager, skins and language if site is not None: setHooks() setSite(site) site.setupCurrentSkin(site.REQUEST) site.REQUEST['HTTP_ACCEPT_LANGUAGE'] = site.Language() return (app, 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 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 afterSetUp(self): self.loginAsPortalOwner() setSite(self.portal) stool = self.portal.portal_setup expected_export = stool.runAllExportSteps() self.expected = TarballImportContext(stool, expected_export['tarball']) setSite(None)
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 afterSetUp(self): self.loginAsPortalOwner() setSite(self.portal) #stool = self.portal.portal_setup #expected_export = stool.runAllExportSteps() #self.expected = TarballImportContext(stool, expected_export['tarball']) setSite(None)
def startKSSCommands(context, request): view = KSSView(context, request) # Alec suggested we should fire the BeforeTraverseEvent, but after # debugging for a while I stopped caring about the event and think # that setSite() is the only thing we're interested in. setSite(view) return view
def get_plone_site(PLONE): import Zope2 app = Zope2.app() from Testing.ZopeTestCase import utils utils._Z2HOST = HOST path = PLONE.split('/') app = utils.makerequest(app) app.REQUEST['PARENTS'] = [app] app.REQUEST.other['VirtualRootPhysicalPath'] = path from zope.globalrequest import setRequest setRequest(app.REQUEST) from AccessControl.SpecialUsers import system as user from AccessControl.SecurityManagement import newSecurityManager newSecurityManager(None, user) _site = app[path[-1]] site = _site.__of__(app) from zope.site.hooks import setSite setSite(site) return site
def addConfiguredSite(dispatcher, site_id, profile_id, snapshot=True, RESPONSE=None, extension_ids=()): """ Add a CMFSite to 'dispatcher', configured according to 'profile_id'. """ site = CMFSite(site_id) dispatcher._setObject(site_id, site) site = dispatcher._getOb(site_id) setSite(site) site._setObject(_TOOL_ID, SetupTool(_TOOL_ID)) setup_tool = getToolByName(site, _TOOL_ID) setup_tool.setBaselineContext('profile-%s' % profile_id) setup_tool.runAllImportStepsFromProfile('profile-%s' % profile_id) for extension_id in extension_ids: setup_tool.runAllImportStepsFromProfile('profile-%s' % extension_id) if snapshot is True: setup_tool.createSnapshot('initial_configuration') if RESPONSE is not None: RESPONSE.redirect('%s/%s/manage_main?update_menu=1' % (dispatcher.absolute_url(), site_id))
def setUp(self): zope.app.appsetup.product.setProductConfigurations(self.conf) zope.app.wsgi.testlayer.BrowserLayer.setUp(self) root = self.getRootFolder() root['app'] = Uvcsite() setSite(root['app']) transaction.commit()
def upgrade_2001(context): # pragma: no cover """ """ site = getToolByName(context, 'portal_url').getPortalObject() portal_setup = site.portal_setup log = logging.getLogger( 'collective.cron.upgrade.2001') try: from plone.app.async.interfaces import IAsyncDatabase from plone.app.async.service import AsyncService except: return service = AsyncService() db = service._db = getUtility(IAsyncDatabase) asyncfs = db.databases.get(db.database_name) itransaction = Zope2.zpublisher_transactions_manager # see plone.app.async.service.AsyncService.getQueues try: service._conn = asyncfs.open() service._conn.onCloseCallback(service.__init__) queues = service.getQueues() queue = queues[''] s = getMultiAdapter((site, queue), i.ICrontabMarker) for idx, item in enumerate(s.annotations['plone'][:]): if isinstance(item, tuple): s.annotations['plone'][idx] = item[1] itransaction.commit() finally: asyncfs.close() setSite(site) log.info('upgrade runned')
def setUp(self): if not os.path.exists(self.dbDir): os.mkdir(self.dbDir) filename = os.path.join(self.dbDir, 'TestData.fs') fsetup = functional.FunctionalTestSetup(self.config_file) self.original = fsetup.base_storage if not os.path.exists(filename): # Generate a new database from scratch and fill it db = database(filename) connection = db.open() root = connection.root() app = root[ZopePublication.root_name] # store the site, because the connection gets closed site = hooks.getSite() self.setUpApplication(app) transaction.commit() connection.close() db.close() hooks.setSite(site) # sets up the db stuff normal fsetup.setUp() # replace the storage with our filestorage fsetup.base_storage = FileStorage(filename) # override close on this instance, so files dont get closed on # setup/teardown of functionsetup fsetup.base_storage.close = lambda: None
def testUpgradeAllProposed(self): request = self.app.REQUEST oldsite = getattr(self.app, self._SITE_ID) stool = oldsite.portal_setup profile_id = 'Products.CMFDefault:default' upgrades = [] for upgrade_info in stool.listUpgrades(profile_id): if isinstance(upgrade_info, list): for info in upgrade_info: if info['proposed']: upgrades.append(info['id']) continue if upgrade_info['proposed']: upgrades.append(upgrade_info['id']) request.form['profile_id'] = profile_id request.form['upgrades'] = upgrades stool.manage_doUpgrades(request) self.assertEqual(stool.getLastVersionForProfile(profile_id), ('2', '2')) newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], '')) setSite(self.app.site) expected_export = self.app.site.portal_setup.runAllExportSteps() setSite(oldsite) upgraded_export = stool.runAllExportSteps() expected = TarballImportContext(stool, expected_export['tarball']) upgraded = TarballImportContext(stool, upgraded_export['tarball']) diff = stool.compareConfigurations(upgraded, expected) self.assertEqual(diff, '', diff)
def test_UnIndex(self): """ Setup a catalog deeper within the containment hierarchy and call the updateIndexes method. The indexed objects should should be restricted to the sublocations. """ from zope.catalog.catalog import indexDocSubscriber from zope.catalog.catalog import unindexDocSubscriber from zope.container.contained import ObjectAddedEvent from zope.container.contained import ObjectRemovedEvent ob = Stub() self.subfolder['ob'] = ob id = self.utility.register(ob) setSite(self.subfolder) res = self.cat.searchResults(name='ob') self.assertEqual(len(res), 0) setSite(None) indexDocSubscriber(ObjectAddedEvent(ob)) setSite(self.subfolder) res = self.cat.searchResults(name='ob') self.assertEqual(len(res), 1) setSite(None) unindexDocSubscriber(ObjectRemovedEvent(ob)) setSite(self.subfolder) res = self.cat.searchResults(name='ob') self.assertEqual(len(res), 0)
def CMFDefaultPortal(db=None, connection=None, environ=None): """Context manager for working with the Plone portal during layer setup:: with CMFDefaultPortal() as portal: ... This is based on the ``z2.zopeApp()`` context manager. See the module ``plone.testing.z2`` for details. Do not use this in a test. Use the 'portal' resource from the PloneFixture layer instead! Pass a ZODB handle as ``db`` to use a specificdatabase. Alternatively, pass an open connection as ``connection`` (the connection will not be closed). """ from zope.site.hooks import setSite, getSite, setHooks setHooks() site = getSite() with z2.zopeApp(db, connection, environ) as app: portal = app[SITE_ID] setSite(portal) z2.login(portal['acl_users'], TEST_USER_ID) try: yield portal finally: z2.logout() if site is not portal: setSite(site)
def get_plone_site(): import Zope2 app = Zope2.app() from Testing.ZopeTestCase import utils utils._Z2HOST = HOST path = PLONE.split('/') app = utils.makerequest(app) app.REQUEST['PARENTS'] = [app] app.REQUEST.other['VirtualRootPhysicalPath'] = path from zope.globalrequest import setRequest setRequest(app.REQUEST) from AccessControl.SpecialUsers import system as user from AccessControl.SecurityManagement import newSecurityManager newSecurityManager(None, user) _site = app[path[-1]] site = _site.__of__(app) from zope.site.hooks import setSite setSite(site) return site
def pushGlobalRegistry(portal, new=None, name=None): """Set a new global component registry that uses the current registry as a base. If you use this, you *must* call ``popGlobalRegistry()`` to restore the original state. If ``new`` is not given, a new registry is created. If given, you must provide a ``zope.component.globalregistry.BaseGlobalComponents`` object. Returns the new registry. Also ensure that the persistent component registry at ``portal`` has the new global registry as its base. """ from zope.site.hooks import setSite, getSite, setHooks site = getSite() localSiteManager = portal.getSiteManager() current = zca.pushGlobalRegistry(new=new) if current not in localSiteManager.__bases__: localSiteManager.__bases__ = (current, ) if site is not None: setHooks() setSite(site) return current
def wrapped_func(*args, **kw): sm, site = getSecurityManager(), getSite() try: return func(*args, **kw) finally: setSecurityManager(sm) setSite(site)
def setUp(self): portal = self.layer['portal'] setSite(portal) self.portal = portal self.qi = getattr(self.portal, 'portal_quickinstaller') self.st = getattr(self.portal, 'portal_setup') self.setUpUser()
def run_ddl_as_script(): parser = setup_parser() options, args = parser.parse_args() if len(args) != 1: parser.print_help() sys.exit(1) return instance_path = args[0] global app # Enable Faux HTTP request object app = spoof_request(app) # Get Plone site object from Zope application server root site = app.unrestrictedTraverse(instance_path) setHooks() setSite(site) site.setupCurrentSkin(app.REQUEST) # Load portal types with enabled IMirroredContent behavior loader.load_models(site) if options.drop: schema.metadata.drop_all() if not options.no_create: schema.metadata.create_all()
def setUp(self): portal = self.layer['portal'] self.request = self.layer['app'].REQUEST setSite(portal) self.portal = portal self.setUpUser() self.setUpContent()
def setUp(self): portal = self.layer['portal'] setSite(portal) self.portal = portal self.st = getattr(self.portal, 'portal_setup') self.base_path = os.path.dirname(i18n.__file__) self.setUpUser()
def setUp(self): portal = self.layer['portal'] setSite(portal) self.portal = portal self.registry = getattr(self.portal, 'portal_registry') self.ct = getattr(self.portal, 'portal_catalog') self.prefix = 'plone.app.querystring.field.skos' self.setUpUser()
def setUp(self): portal = self.layer['portal'] setSite(portal) self.portal = portal self.qi = getattr(self.portal, 'portal_quickinstaller') self.wt = getattr(self.portal, 'portal_workflow') self.st = getattr(self.portal, 'portal_setup') self.setUpUser()
def afterSetUp(self): setHooks() setSite(self.portal) self.setRoles(('Manager', )) portal_setup = self.portal.portal_setup # wait a bit or we get duplicate ids on import time.sleep(0.2) portal_setup.runAllImportStepsFromProfile('profile-plone.app.portlets:z3ctesting')
def export(self): oldsite = getattr(self.app, self.site_id) setSite(oldsite) stool = oldsite.portal_setup upgraded_export = stool.runAllExportSteps() upgraded = TarballImportContext(stool, upgraded_export['tarball']) return stool.compareConfigurations(upgraded, self.expected)
def afterSetUp(self): setSite(self.app.site) self.app.site.setupCurrentSkin(self.app.REQUEST) newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], '')) # sessioning setup sdm = self.app.session_data_manager self.app.REQUEST.set_lazy('SESSION', sdm.getSessionData)
def migrate(self): oldsite = getattr(self.app, self.site_id) mig = oldsite.portal_migration components = getattr(oldsite, '_components', None) if components is not None: setSite(oldsite) result = mig.upgrade(swallow_errors=False) return (oldsite, result)
def setUp(self): portal = self.layer['portal'] setSite(portal) self.portal = portal self.qi = api.portal.get_tool('portal_quickinstaller') self.wt = api.portal.get_tool('portal_workflow') self.st = api.portal.get_tool('portal_setup') self.setUpUser()
def afterSetUp(self): setHooks() setSite(self.portal) self.manager = getUtility(IPortletManager, name=u'plone.leftcolumn') self.cat = self.manager[USER_CATEGORY] self.cat[user_name] = PortletAssignmentMapping(manager=u'plone.leftcolumn', category=USER_CATEGORY, name=user_name)
def afterSetUp(self): setHooks() setSite(self.portal) self.setRoles(('Manager'), ) self.portal.invokeFactory('Document', 'doc1') self.portal.invokeFactory('Document', 'doc2') self.portal.portal_membership.getMemberById('test_user_1_').setMemberProperties( {'fullname': 'Test user'})
def addPloneSite(context, site_id, title='Plone site', description='', create_userfolder=True, email_from_address='', email_from_name='', validate_email=True, profile_id=_DEFAULT_PROFILE, snapshot=False, extension_ids=(), base_contenttypes_profile=_ATCONTENTTYPES_PROFILE, setup_content=True, default_language='en'): """Add a PloneSite to the context.""" context._setObject(site_id, PloneSite(site_id)) site = context._getOb(site_id) site.setLanguage(default_language) site[_TOOL_ID] = SetupTool(_TOOL_ID) setup_tool = site[_TOOL_ID] notify(SiteManagerCreatedEvent(site)) setSite(site) setup_tool.setBaselineContext('profile-%s' % profile_id) setup_tool.runAllImportStepsFromProfile('profile-%s' % profile_id) if base_contenttypes_profile is not None \ and base_contenttypes_profile in _CONTENTTYPES_PROFILES: profile = 'profile-%s' % base_contenttypes_profile setup_tool.runAllImportStepsFromProfile(profile) # Only set up content if a base contenttypes profile has been provided. if setup_content: if base_contenttypes_profile == _ATCONTENTTYPES_PROFILE: content_profile = _AT_CONTENT_PROFILE else: content_profile = _DEX_CONTENT_PROFILE setup_tool.runAllImportStepsFromProfile('profile-%s' % content_profile) props = dict( title=title, description=description, email_from_address=email_from_address, email_from_name=email_from_name, validate_email=validate_email, ) # Do this before applying extension profiles, so the settings from a # properties.xml file are applied and not overwritten by this site.manage_changeProperties(**props) for extension_id in extension_ids: setup_tool.runAllImportStepsFromProfile('profile-%s' % extension_id) if snapshot is True: setup_tool.createSnapshot('initial_configuration') return site
def pushGlobalRegistry(new=None): """Set a new global component registry that uses the current registry as a a base. If you use this, you *must* call ``popGlobalRegistry()`` to restore the original state. If ``new`` is not given, a new registry is created. If given, you must provide a ``zope.component.globalregistry.BaseGlobalComponents`` object. Returns the new registry. """ from zope.component import globalregistry # Save the current top of the stack in a registry current = globalregistry.base # The first time we're called, we need to put the default global # registry at the bottom of the stack, and then patch the class to use # the stack for loading pickles. Otherwise, we end up with POSKey and # pickling errors when dealing with persistent registries that have the # global registry (globalregistry.base) as a base if len(_REGISTRIES) == 0: _REGISTRIES.append(current) globalregistry.BaseGlobalComponents._old__reduce__ = ( globalregistry.BaseGlobalComponents.__reduce__) globalregistry.BaseGlobalComponents.__reduce__ = (lambda self: (loadRegistry, (self.__name__, ))) if new is None: name = 'test-stack-%d' % len(_REGISTRIES) new = globalregistry.BaseGlobalComponents(name=name, bases=(current, )) logger.debug("New component registry: %s based on %s", name, current.__name__) else: logger.debug("Push component registry: %s", new.__name__) _REGISTRIES.append(new) # Monkey patch this into the three (!) places where zope.component # references it as a module global variable _hookRegistry(new) # Reset the site manager hook so that getSiteManager() returns the base # again from zope.component import getSiteManager getSiteManager.reset() try: from zope.site.hooks import setSite, setHooks except ImportError: pass else: setSite() setHooks() return new
def setUp(self): portal = self.layer['portal'] self.request = self.layer['app'].REQUEST setSite(portal) self.portal = portal self.fti = add_folder_type(self.portal) self.setUpUser() self.portal.invokeFactory('folder', 'folder') self.setUpContent()
def afterSetUp(self): setHooks() setSite(self.portal) self.setRoles(('Manager', )) portal_setup = self.portal.portal_setup # wait a bit or we get duplicate ids on import time.sleep(0.2) portal_setup.runAllImportStepsFromProfile( 'profile-plone.app.portlets:z3ctesting')
def addPloneSite(context, site_id, title='Plone site', description='', profile_id=_DEFAULT_PROFILE, content_profile_id=_CONTENT_PROFILE, snapshot=False, extension_ids=(), setup_content=True, default_language='en', portal_timezone='UTC'): """Add a PloneSite to the context.""" context._setObject(site_id, PloneSite(site_id)) site = context._getOb(site_id) site.setLanguage(default_language) # Set the accepted language for the rest of the request. This makes sure # the front-page text gets the correct translation also when your browser # prefers non-English and you choose English as language for the Plone # Site. request = context.REQUEST request['HTTP_ACCEPT_LANGUAGE'] = default_language site[_TOOL_ID] = SetupTool(_TOOL_ID) setup_tool = site[_TOOL_ID] notify(SiteManagerCreatedEvent(site)) setSite(site) setup_tool.setBaselineContext('profile-%s' % profile_id) setup_tool.runAllImportStepsFromProfile('profile-%s' % profile_id) reg = queryUtility(IRegistry, context=site) reg['plone.portal_timezone'] = portal_timezone reg['plone.available_timezones'] = [portal_timezone] reg['plone.default_language'] = default_language reg['plone.available_languages'] = [default_language] if setup_content: setup_tool.runAllImportStepsFromProfile('profile-%s' % content_profile_id) props = dict( title=title, description=description, ) # Do this before applying extension profiles, so the settings from a # properties.xml file are applied and not overwritten by this site.manage_changeProperties(**props) for extension_id in extension_ids: setup_tool.runAllImportStepsFromProfile('profile-%s' % extension_id) if snapshot is True: setup_tool.createSnapshot('initial_configuration') return site
def __init__(self, portal, admin): root = makerequest.makerequest(app) self.portal = getattr(root, portal, None) admin = root.acl_users.getUserById(admin) admin = admin.__of__(self.portal.acl_users) newSecurityManager(None, admin) setHooks() setSite(self.portal) self.portal.setupCurrentSkin(self.portal.REQUEST)
def afterSetUp(self): site = self.app.site setSite(site) site.setupCurrentSkin(self.app.REQUEST) site.acl_users._doAddUser('god', 'secret', ['Manager'], []) user = site.acl_users.getUser('god').__of__(site.acl_users) newSecurityManager(None, user) # sessioning setup sdm = self.app.session_data_manager self.app.REQUEST.set_lazy('SESSION', sdm.getSessionData)
def testSetUp(self): super(SilvaLayer, self).testSetUp() # Get the Silva Root and set it as a local site app = super(SilvaLayer, self).get_application() self._silva_root = app.root setSite(self._silva_root) setHooks() # List of created browsers self._browsers = []
def testTearDown(self): self.loginAsPortalOwner() if 'test-folder' in self['portal'].objectIds(): self['portal'].manage_delObjects('test-folder') # Set up the local site manager from zope.site.hooks import setSite setSite(self['portal']) self['portal'].portal_membership.deleteMembers([PLONE_MANAGER_NAME]) self.setRoles() self.login() super(IntegrationTesting, self).testTearDown()
def setUp(self): provideAdapter(SharingXMLAdapter, name='plone.app.workflow.sharing') site = Folder('plone') make_objectmanager_site(site) setHooks() setSite(site) sm = getSiteManager() self.site = site self.sm = sm