def test_thread_moved_missing_memberdata(self): n = self._make_one() n.thread_moved_text = u'salutation:%(salutation)s\nthreadtitle:%(threadtitle)s\nthreadurl:%(threadurl)s\nboardtitle:%(boardtitle)s\nsignature:%(mailsignature)s' n.signature='signature' n.salutations = {u'Herr':u'Sehr geehrter Herr %(firstname)s %(lastname)s', u'Frau':u'Sehr geehrte Frau %(firstname)s %(lastname)s'} # if a user posts more than one comment, he still should get notified only once. comment = CommentMock(id='testcomment2', title='Re: test', conversation=self.app.testforum.testthread, text='Awesome!', creator='123456') self.app.testforum.testthread.comments.append(comment) self.app.testforum.testthread._setObject(comment.id, comment) mh = queryUtility(IMailHost) mh.emails = [] mtool = queryUtility(IMembershipTool) mtool.members['654321'] = None n.thread_moved(self.app.testforum.testthread) got = len(mh.emails) self.failUnless(got==1, 'notifier should have sent 1 email, got %s instead' % got) mail = mh.emails[0] got = {} got.update([tuple(kv.split(':', 1)) for kv in mail[0][0].as_string().split('\n\n')[1].split('\n')]) self.failUnless(got['threadtitle']=='test thread', 'unexpected thread title, got "%s"' % got['threadtitle']) self.failUnless(got['threadurl']=='http://nohost/testforum/testthread', 'unexpected thread url, got "%s"' % got['threadurl']) self.failUnless(got['boardtitle']=='test forum', 'unexpected board title, got "%s"' % got['boardtitle']) self.failUnless(got['signature']=='signature', 'unexpected signature') self.failUnless(got['salutation']=='Sehr geehrter Herr Max Mustermann', 'unexpected salutation, got "%s"' % got['salutation'])
def unmarkTargetOnRemove(alias, event): """When the alias is created, """ target = aq_inner(alias._target) if target is not None and IHasAlias.providedBy(target): intids = queryUtility(IIntIds) catalog = queryUtility(ICatalog) if intids is not None and catalog is not None: try: to_id = intids.getId(target) except KeyError: logger.error("Alias target %s does not have an intid" % target) return alias_base = aq_base(alias) for rel in catalog.findRelations({ 'to_id': to_id, 'from_interfaces_flattened': IAlias, 'from_attribute': '_aliasTarget', }): # abort if there is another alias if alias_base is not rel.from_object: return noLongerProvides(target, IHasAlias)
def _verifyImport(self, obj): util = queryUtility(IDummyInterface, name=u'foo') self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) util = queryUtility(IDummyInterface) self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) util = queryUtility(IDummyInterface, name='dummy tool name') self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) self.assertEqual(util.meta_type, 'dummy tool') # make sure we can get the tool by normal means tool = getattr(self.app, 'dummy_tool') self.assertEqual(tool.meta_type, 'dummy tool') self.assertEquals(repr(aq_base(util)), repr(aq_base(tool))) util = queryUtility(IDummyInterface, name='dummy tool name2') self.failUnless(IDummyInterface.providedBy(util)) self.failUnless(util.verify()) self.assertEqual(util.meta_type, 'dummy tool2') # make sure we can get the tool by normal means tool = getattr(self.folder, 'dummy_tool2') self.assertEqual(tool.meta_type, 'dummy tool2') self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))
def test_unregister_behavior(self): # Test taxonomy registration taxonomy = queryUtility(ITaxonomy, name='collective.taxonomy.test') self.assertIsNotNone(taxonomy) # Unregister behavior taxonomy.unregisterBehavior() # Test behavior registration behavior = queryUtility(IBehavior, name=taxonomy.getGeneratedName()) self.assertIsNone(behavior) # Test index creation pc = api.portal.get_tool('portal_catalog') self.assertNotIn('taxonomy_test', pc.indexes()) # Test indexer registration sm = getSiteManager() indexer = sm._adapter_registrations.get( ((IDexterityContent, IZCatalog), IIndexer, 'taxonomy_test'), None) self.assertIsNone(indexer) # Test querystring configuration registry = queryUtility(IRegistry) self.assertIsNotNone(registry) prefix = 'plone.app.querystring.field.taxonomy_test' self.assertRaises( KeyError, registry.forInterface, IQueryField, prefix=prefix) # noqa
def register(fti): """Helper method to: - register an FTI as a local utility - register a local factory utility - register an add view """ fti = aq_base(fti) # remove acquisition wrapper site = getUtility(ISiteRoot) site_manager = getSiteManager(site) portal_type = fti.getId() fti_utility = queryUtility(IDexterityFTI, name=portal_type) if fti_utility is None: site_manager.registerUtility( fti, IDexterityFTI, portal_type, info='plone.dexterity.dynamic' ) factory_utility = queryUtility(IFactory, name=fti.factory) if factory_utility is None: site_manager.registerUtility( DexterityFactory(portal_type), IFactory, fti.factory, info='plone.dexterity.dynamic' )
def __call__(self): colorsDict = self.calendar.queryColors criterias = interfaces.IListBaseQueryCriteria(self.context)() css = '' if not colorsDict: return css for fieldid, selectedItems in [(a['i'], a.get('v')) for a in criterias]: if not colorsDict.has_key(fieldid): continue for i in range(len(selectedItems)): cValName = str(component.queryUtility(IURLNormalizer).normalize(safe_unicode(selectedItems[i]))) color = None for k, v in colorsDict.get(fieldid, {}).items(): k = safe_unicode(k) if k == cValName or str(component.queryUtility(IURLNormalizer).normalize(k)) == cValName: color = v break if color: css += 'label.%scolorIndex-%s {\n' % (fieldid, str(i)) css += ' color: %s;\n' % (str(color)) css += '}\n\n' return css
def __init__(self, taskName, configId, scheduleIntervalSeconds=60, taskConfig=None): """ @param deviceId: the Zenoss deviceId to watch @type deviceId: string @param taskName: the unique identifier for this task @type taskName: string @param scheduleIntervalSeconds: the interval at which this task will be collected @type scheduleIntervalSeconds: int @param taskConfig: the configuration for this task """ super(NmapPingTask, self).__init__(taskName, configId, scheduleIntervalSeconds, taskConfig=None) # Needed for interface self.name = taskName self.configId = configId self.state = TaskStates.STATE_IDLE self.interval = scheduleIntervalSeconds if taskConfig is None: raise TypeError("taskConfig cannot be None") self._preferences = taskConfig self._daemon = component.getUtility(ZenCollector.interfaces.ICollector) self._dataService = component.queryUtility(ZenCollector.interfaces.IDataService) self._eventService = component.queryUtility(ZenCollector.interfaces.IEventService) self._pings = 0 self._nmapPresent = False # assume nmap is not present at startup self._nmapIsSuid = False # assume nmap is not SUID at startup self._cycleIntervalReasonable = True # assume interval is fine at startup self.collectorName = self._daemon._prefs.collectorName # maps task name to ping down count and time of last ping down self._down_counts = defaultdict(lambda: (0, None))
def render(self): # Test that our installation was successful pau = queryUtility(IAuthentication) if pau is None or type(pau) is not PluggableAuthenticatorPlugin: if pau is not None: st = "PAU not installed correctly: %s" % pau utilities = getUtilitiesFor(IAuthentication) st += "\n Available utilities are: %s" % [u for u in utilities] return st else: return "PAU Utility not found" st = ('Success: Credentials plugins= %s; Authenticator plugins= %s' % (pau.credentialsPlugins, pau.authenticatorPlugins)) roleMgr = IPrincipalRoleManager(self.context) p = roleMgr.getPrincipalsForRole('gfn.Administrator') st += "\n Administrators: %s" %p for ut in pau.credentialsPlugins: if queryUtility(ICredentialsPlugin, name=ut) is None: st += '\n Could not find credentials plugin for %s' % ut for ut in pau.authenticatorPlugins: if queryUtility(IAuthenticatorPlugin, name=ut) is None: st += '\n Could not find authenticator plugin for %s' % ut return st
def __init__(self, fti=None): if not fti: return sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_connection, default=None) if sql_connection: self.connection_name = sql_connection.name else: sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_table, default=None) if sql_connection: self.connection_name = sql_connection.name else: processor = SQLBaseConnectionUtility(fti) connection_name = processor.name LOG.info('Base connection utility registered as '+connection_name) gsm = getGlobalSiteManager() gsm.registerUtility(processor, ISQLBaseConnectionUtility, name=connection_name) self.connection_name = connection_name self.sql_table = fti.sql_table self.factory = fti.factory self.sql_id_column = getattr(fti, 'sql_id_column', None) and getattr(fti, 'sql_id_column', None) or 'id' fieldnames = {} for field_name, field in schema.getFieldsInOrder( fti.lookupSchema() ): if getattr(field, 'sql_column', None): sql_column = getattr(field, 'sql_column', None) fieldnames[field_name] = sql_column for line in getattr(fti, 'sql_fields_columns', []): fieldnames[line.split(':')[0]] = line.split(':')[1] self.fieldnames = fieldnames
def get_plone_members(self): """ return filtered list of plone members as DisplayList """ global fmp_tool if fmp_tool and queryUtility(IFastmemberpropertiesTool, 'fastmemberproperties_tool'): log.debug("Use fastmemberpropertiestool to get memberproperties!") fmp_tool = queryUtility(IFastmemberpropertiesTool, 'fastmemberproperties_tool') member_properties = fmp_tool.get_all_memberproperties() else: log.info("We use plone API to get memberproperties, this is very \ slow on many members, please install inqbus.plone.fastmemberproperties to make it fast!") acl_userfolder = getToolByName(self, 'acl_users') member_objs = acl_userfolder.getUsers() member_properties = {} for member in member_objs: probdict = {} probdict['id'] = member.getUserId() probdict['email'] = member.getProperty('email') probdict['fullname'] = safe_unicode(member.getProperty('fullname')) member_properties[probdict['id']] = probdict if not member_properties: return [] try: results = atapi.DisplayList([(id, property['fullname'] + ' - ' + property['email']) for id, property in member_properties.items() if config.EMAIL_RE.findall(property['email'])]) except TypeError, e: log.error(":get_plone_members: error in member_properties %s/ \ properties:'%s'" % (e, member_properties.items()))
def test_enabled_uninstalled(self): dsb = DummyStorageBackend() getSiteManager().registerUtility( dsb, IStorageBackend, name='dummy_storage') utilities = queryUtility(IUtilityRegistry, 'repodono.storage.backends') utilities.enable('dummy_storage') vocab = queryUtility( IVocabularyFactory, name='repodono.storage.backends')(None) self.assertEqual(vocab.getTermByToken( 'dummy_storage').token, 'dummy_storage') getSiteManager().unregisterUtility( dsb, IStorageBackend, name='dummy_storage') vocab = queryUtility( IVocabularyFactory, name='repodono.storage.backends')(None) self.assertEqual(list(vocab), []) # registry should be untouched at this point registry = queryUtility(IRegistry) self.assertEqual( registry['repodono.storage.backends'], [u'dummy_storage']) # shouldn't break anything. utilities.disable('unrelated') self.assertEqual(list(vocab), []) # The bad value is no longer stored. self.assertEqual(registry['repodono.storage.backends'], [])
def setupDefaultImages(site): """ Move images from valentine-imagescales """ if ('valentine-imagescales' not in site.objectIds() or IDepictionTool.providedBy(site['valentine-imagescales'])): return setupGenericImage(site) valentine = site['valentine-imagescales'] tool = queryUtility(IDepictionTool) for image in valentine.objectIds(): if image not in tool.objectIds(): cb = valentine.manage_cutObjects(image) tool.manage_pasteObjects(cb) oldUrl = "/".join(valentine.getPhysicalPath()) site.manage_delObjects(['valentine-imagescales']) # Add alias storage = queryUtility(IRedirectionStorage) storage.add(oldUrl, '/'.join(tool.getPhysicalPath())) # Setup generic image setupGenericImage(site)
def normalize(self, text, locale=None, max_length=MAX_LENGTH): """ Returns a normalized text. text has to be a unicode string and locale should be a normal locale, for example: 'pt-BR', 'sr@Latn' or 'de' """ if locale is not None: # Try to get a normalizer for the locale util = queryUtility(IIDNormalizer, name=locale) parts = LOCALE_SPLIT_REGEX.split(locale) if util is None and len(parts) > 1: # Try to get a normalizer for the base language if we asked # for one for a language/country combination and found none util = queryUtility(IIDNormalizer, name=parts[0]) # be defensive: if queryUtility() returns an instance of the same # normalizer class as this one, we'll loop forever until # "RuntimeError: maximum recursion depth exceeded" (ticket #11630) if util is not None and util.__class__ is not self.__class__: text = util.normalize(text, locale=locale) text = baseNormalize(text) # lowercase text text = text.lower() text = IGNORE_REGEX.sub('', text) text = NON_WORD_REGEX.sub('-', text) text = MULTIPLE_DASHES_REGEX.sub('-', text) text = EXTRA_DASHES_REGEX.sub('', text) return cropName(text, maxLength=max_length)
def publishTraverse(self, request, name): if not self.fti_id: return super(SQLDexterityPublishTraverse, self).publishTraverse(request, name) connection = queryUtility(ISQLConnectionsUtility, name=self.fti_id, default=None) if connection == None and self.portal_type: fti = queryUtility(IDexterityFTI, name=self.fti_id, default=None) if not fti: return None updateConnectionsForFti(self.fti) connection = getUtility(ISQLConnectionsUtility, name=self.fti_id) name = name.split('/')[0] name = name.split('++')[0] name = name.split('@@')[0] sql_id_column = self.fti.sql_id_column factory_utility = queryUtility(IFactory, name=self.fti.factory) catalog = getToolByName(getSite(), 'portal_catalog') results = catalog.unrestrictedSearchResults(portal_type=self.fti_id, id=name) if results: sql_id = results[0].sql_id else: sql_id = name try: sql_items = connection.query(id=sql_id) except: sql_items = [] if sql_items: sql_item = sql_items[0] sql_item_id = getattr(sql_item, sql_id_column, False) item = factory_utility(sql_id=sql_item_id) item.sql_virtual = True return item.__of__(self.context) return super(SQLDexterityPublishTraverse, self).publishTraverse(request, name)
def setupGenericImage(site): """ Add generic image within portal_depiction if it doesn't exists """ tool = queryUtility(IDepictionTool, context=site) tool = tool.__of__(site) if 'generic' in tool.objectIds(): return img = site.restrictedTraverse( '++resource++eea.depiction.images/generic.jpg') data = img.GET() # needed for tests storage = queryUtility(IStorage, name="__builtin__.str") if storage is None: from plone.namedfile.storages import StringStorable provideUtility(StringStorable(), IStorage, name="__builtin__.str") image = NamedBlobImage(data=data, contentType="image/jpeg", filename=u"generic.jpg") id = tool.invokeFactory('Image', id='generic', title='Generic') obj = tool._getOb(id) if IBaseObject.providedBy(obj): obj.edit(image=image) else: obj.image = image
def onExternalChanged(obj, evt): """ Handle external URL """ if not evt.external: return request = getattr(obj, 'REQUEST', None) if not request: return mutator = queryAdapter(obj, IVisualizationConfig) if not mutator: return new_json = {'items': [], 'properties': {}} new_json['properties'].update(mutator.json.get('properties', {})) data = queryUtility(IExternalData) if not data: return datafile = StringIO(data(evt.external)) converter = queryUtility(ITable2JsonConverter) try: columns, data = converter(datafile) except Exception, err: logger.exception(err) return
def reindex(self, batch=1000, skip=0): """ find all contentish objects (meaning all objects derived from one of the catalog mixin classes) and (re)indexes them """ requestFactory = queryUtility(IRequestFactory) indexProcessor = queryUtility(IZeroCMSIndexQueueProcessor, name="zerocms") zodb_conn = self.context._p_jar log = self.mklog() log('reindexing documents to ZeroCMS...\n') if skip: log('skipping indexing of %d object(s)...\n' % skip) real = timer() # real time lap = timer() # real lap time (for intermediate commits) cpu = timer(clock) # cpu time processed = 0 updates = {} # list to hold data to be updated count = 0 for path, obj in findObjects(self.context): if indexable(obj): if getOwnIndexMethod(obj, 'indexObject') is not None: log('skipping indexing of %r via private method.\n' % obj) continue count += 1 if count <= skip: continue indexProcessor.index(obj) processed += 1 zodb_conn.cacheGC(); log('All documents exported to ZeroCMS.\n') msg = 'processed %d items in %s (%s cpu time).' msg = msg % (processed, real.next(), cpu.next()) log(msg) logger.info(msg)
def __call__(self, **kwargs): if self.request: kwargs.update(self.request.form) url = kwargs.get('url', '') if not url: logger.exception('Invalid URL: %s', url) return "" reader = kwargs.get('reader', '') reader = queryUtility(IBabelReader, name=reader) if not reader: logger.exception('Unknown babel reader: %s', reader) return "" write = kwargs.get('writer', '') writer = queryUtility(IBabelWriter, name=write) if not writer: logger.exception('Unknown babel writer: %s', writer) return "" try: items = reader(url) except Exception, err: logger.exception(err) return ""
def _unauthenticatedPrincipal(): group = component.queryUtility(interfaces.IUnauthenticatedGroup) if group is not None: _unauthenticatedGroup(group.id) group = component.queryUtility(interfaces.IEveryoneGroup) if group is not None: _everybodyGroup(group.id)
def _translate(msgid, domain=None, mapping=None, context=None, target_language=None, default=None): if isinstance(msgid, (MessageID, Message)): domain = msgid.domain default = msgid.default mapping = msgid.mapping if default is None: default = msgid if domain: util = queryUtility(ITranslationDomain, domain) if util is None: util = queryUtility(IFallbackTranslationDomainFactory) if util is not None: util = util(domain) else: util = queryUtility(IFallbackTranslationDomainFactory) if util is not None: util = util() if util is None: return interpolate(default, mapping) return util.translate(msgid, mapping, context, target_language, default)
def getPageSiteLayout(context): """Get the path to the site layout for a page. This is generally only appropriate for the view of this page. For a generic template or view, use getDefaultSiteLayout(context) instead. """ layoutAware = ILayoutAware(context, None) if layoutAware is not None: if getattr(layoutAware, 'pageSiteLayout', None): return layoutAware.pageSiteLayout # Note: the sectionSiteLayout on context is for pages *under* context, not # necessarily context itself parent = aq_parent(aq_inner(context)) while parent is not None: layout = ILayoutAware(parent, None) if layout is not None: if getattr(layout, 'sectionSiteLayout', None): return layout.sectionSiteLayout parent = aq_parent(aq_inner(parent)) fti = queryUtility(IDexterityFTI, name=context.portal_type) if fti is not None and IPageFTI.providedBy(fti): if fti.default_site_layout: return fti.default_site_layout registry = queryUtility(IRegistry) if registry is None: return None return registry.get(DEFAULT_SITE_LAYOUT_REGISTRY_KEY)
def getObject(self, REQUEST=None): path = self.getPath().split('/') if not path: return None parent = aq_parent(self) if (aq_get(parent, 'REQUEST', None) is None and _GLOBALREQUEST_INSTALLED and _REQUESTCONTAINER_EXISTS): request = getRequest() if request is not None: # path should be absolute, starting at the physical root parent = self.getPhysicalRoot() request_container = RequestContainer(REQUEST=request) parent = aq_base(parent).__of__(request_container) if len(path) > 1: try: parent = parent.unrestrictedTraverse(path[:-1]) except: if path[:-2] == 'data-'+self.portal_type: parent = queryMultiAdapter((None, ICollectiveBehaviorSQLLayer), IBrowserView, name='data-'+name, default=None) try: return parent.restrictedTraverse(path[-1]) except: connection = queryUtility(ISQLConnectionsUtility, name=self.portal_type, default=None) if connection == None and self.portal_type: fti = queryUtility(IDexterityFTI, name=self.portal_type, default=None) if not fti: return None updateConnectionsForFti(fti) connection = queryUtility(ISQLConnectionsUtility, name=self.portal_type, default=None) return connection.getVirtualItem(self.sql_id, context=parent)
def updateRelations(obj, event): """Re-register relations, after they have been changed. """ catalog = component.queryUtility(ICatalog) intids = component.queryUtility(IIntIds) if catalog is None or intids is None: return # check that the object has an intid, otherwise there's nothing to be done try: obj_id = intids.getId(obj) except KeyError: # The object has not been added to the ZODB yet return # remove previous relations coming from id (now have been overwritten) # have to activate query here with list() before unindexing them so we don't # get errors involving buckets changing size rels = list(catalog.findRelations({'from_id': obj_id})) for rel in rels: catalog.unindex(rel) # add new relations addRelations(obj, event)
def setupVarious(context): """ Custom setup """ if context.readDataFile('scoreboard.visualization.txt') is None: return ds = queryUtility(IDavizSettings) if not ds.disabled('daviz.properties', 'ScoreboardVisualization'): logger.info('Disabling Daviz Properties for ScoreboardVisualization') ds.settings.setdefault('forbidden.daviz.properties', []) ds.settings['forbidden.daviz.properties'].append( 'ScoreboardVisualization') ptool = queryUtility(IPropertiesTool) if not getattr(ptool, 'scoreboard_properties', None): ptool.manage_addPropertySheet( 'scoreboard_properties', 'Scoreboard Properties') stool = getattr(ptool, 'scoreboard_properties', None) eu = stool.getProperty('EU', None) if not eu: default = json.dumps(EU, indent=2) stool.manage_addProperty('EU', default, 'text') whitelist = stool.getProperty('WHITELIST', None) if not whitelist: default = json.dumps(WHITELIST, indent=2) stool.manage_addProperty('WHITELIST', default, 'text')
def queryResourceDirectory(type, name): """Find the IResourceDirectory of the given name and type. Returns None if not found. """ # 1. Persistent resource directory: # Try (persistent resource directory)/$type/$name res = queryUtility(IResourceDirectory, name=u'persistent') if res: try: return res[type][name] except (KeyError, NotFound,): pass # pragma: no cover # 2. Global resource directory: # Try (global resource directory)/$type/$name res = queryUtility(IResourceDirectory, name=u'') if res: try: return res[type][name] except (KeyError, NotFound,): pass # pragma: no cover # 3. Packaged type-specific resource directory: # Try (directory named after type + name) identifier = u'++%s++%s' % (type, name) res = queryUtility(IResourceDirectory, name=identifier) if res is not None: return res return None
def test_global_components_not_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 = 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) # Register FTI utility and factory utility self.mock_utility(fti, IDexterityFTI, name=portal_type) self.mock_utility(DexterityFactory(portal_type), IFactory, name=portal_type) # We expect to always be able to unregister without error, even if the # component exists. The factory is only unregistered if it was registered # with info='plone.dexterity.dynamic'. self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough() self.replay() ftiRemoved(fti, ObjectRemovedEvent(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 generate(self): """the rendered feed. @return: tuple of data and mimetype. """ producer = queryUtility(IFeedSkeletonProducer, name=self.name) if producer is None: return None, None tree = producer() named_modifiers = list(getAdapters((self.feed, tree), IFeedModifier)) named_modifiers.sort(key=operator.itemgetter(0)) namespaces = Set() for name, modifier in named_modifiers: ns = modifier.modify() namespaces.update(ns) mimetype = IMimeTypeLookup(tree) prefixmap = {} for ns in namespaces: prefix = queryUtility(INamespacePrefix, name=ns) if prefix is None: continue prefixmap[ns] = prefix writer = XMLWriter(tree, prefixmap) result = writer(), mimetype return result
def purge(event): """Asynchronously send PURGE requests """ request = event.request annotations = IAnnotations(request, None) if annotations is None: return paths = annotations.get(KEY, None) if paths is None: return registry = queryUtility(IRegistry) if registry is None: return if not isCachePurgingEnabled(registry=registry): return purger = queryUtility(IPurger) if purger is None: return settings = registry.forInterface(ICachePurgingSettings, check=False) for path in paths: for url in getURLsToPurge(path, settings.cachingProxies): purger.purgeAsync(url)
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 = 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) # We expect to always be able to unregister without error, even if the # components do not exists (as here) self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough() self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name=portal_type)).passthrough() self.replay() # 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.assertEquals(None, queryUtility(IDexterityFTI, name=portal_type)) self.assertEquals(None, queryUtility(IFactory, name=portal_type))
def revisionfiles(self, unrestricted=False): """ All the revision files, ordered """ if unrestricted: catalog = getMultiAdapter((self.context, self.context.REQUEST), name=u'plone_tools').catalog() items = catalog.unrestrictedSearchResults(**{'object_provides':IRevisionFile.__identifier__, 'sort_order':'getId', 'path':'/'.join(self.context.getPhysicalPath())}) else: items = self.context.getFolderContents({'object_provides':IRevisionFile.__identifier__, 'sort_order':'getId', }) items = sorted(items, key=attrgetter('effective'), reverse=True) if items: portal_type = items[0].portal_type priority_utility = queryUtility(IRevisionWorkflowUtility, name=portal_type) priority_utility = not priority_utility and queryUtility(IRevisionWorkflowUtility) if priority_utility: priority_map = priority_utility.priority_map() try: items = sorted(items, key=lambda x: (priority_map.get(x.review_state, {}).get('priority'), x.effective)) except TypeError: # Missing.value on items[0].review_state pass items.reverse() if unrestricted: return [item._unrestrictedGetObject() for item in items] else: return [item.getObject() for item in items]
def test_ct_checkliste_schema(self): fti = queryUtility(IDexterityFTI, name='Checkliste') schema = fti.lookupSchema() self.assertEqual(ICheckliste, schema)
def test_ct_contracting_process_schema(self): fti = queryUtility(IDexterityFTI, name='Contracting Process') schema = fti.lookupSchema() self.assertEqual(IContractingProcess, schema)
def test_factory(self): fti = queryUtility(IDexterityFTI, name='collective.conference.track') factory = fti.factory new_object = createObject(factory) self.failUnless(ITrack.providedBy(new_object))
def test_schema(self): fti = queryUtility(IDexterityFTI, name='collective.conference.track') schema = fti.lookupSchema() self.assertEquals(ITrack, schema)
def test_fti(self): fti = queryUtility(IDexterityFTI, name='collective.conference.track') self.assertNotEquals(None, fti)
def test_ct_checkliste_globally_not_addable(self): setRoles(self.portal, TEST_USER_ID, ['Contributor']) fti = queryUtility(IDexterityFTI, name='Checkliste') self.assertFalse(fti.global_allow, u'{0} is globally addable!'.format(fti.id))
def test_ct_checkliste_fti(self): fti = queryUtility(IDexterityFTI, name='Checkliste') self.assertTrue(fti)
def caltool(self): if PRODUCTS_CMFCALENDAR_INSTALLED: return queryUtility(ICalendarTool) return None
def tile_id(self): return queryUtility(IIDNormalizer).normalize( self.data.get('tile_title') )
def uidtool(self): if PRODUCTS_CMFUID_INSTALLED: return queryUtility(IUniqueIdHandler) return None
def edit_comment_allowed(): # Check if editing comments is allowed in the registry registry = queryUtility(IRegistry) settings = registry.forInterface(IDiscussionSettings, check=False) return settings.edit_comment_enabled
def syndtool(self): return queryUtility(ISyndicationTool)
import sys from Testing.makerequest import makerequest import transaction from zope.component import queryUtility, queryMultiAdapter from plone.i18n.normalizer.interfaces import IURLNormalizer from Products.CMFPlone.utils import _createObjectByType from AccessControl.SecurityManagement import \ newSecurityManager, noSecurityManager from Products.PloneHelpCenter.interfaces import IHelpCenterContent from Products.PloneHelpCenter.browser.helpcenter import HelpCenterView normalize = queryUtility(IURLNormalizer).normalize app = makerequest(app) acl_users = app.acl_users user = acl_users.getUser(adminUser) if user: user = user.__of__(acl_users) newSecurityManager(None, user) else: print "Retrieving admin user failed" sys.exit(1) phc = app.unrestrictedTraverse(myPHC) print phc
def permission_exists(permission_id): permission = queryUtility(IPermission, permission_id) return permission is not None
def test_ct_source_schema(self): fti = queryUtility(IDexterityFTI, name='Source') schema = fti.lookupSchema() self.assertEqual(ISource, schema)
def sortProperties(self, strJson, indent=1): """ Sort JSON properties """ utils = queryUtility(IVisualizationJsonUtils) return utils.sortProperties(strJson, indent)
def title(self): site = queryUtility(ISiteRoot) if site is None: # fallback return aq_parent(aq_inner(self)).title return site.title
def test_ct_source_fti(self): fti = queryUtility(IDexterityFTI, name='Source') self.assertTrue(fti)
def render(self): currentValues = self.value or {} criteria = self.getCriteria() html = '' for fieldid, selectedItems in [(a['i'], a['v']) for a in criteria]: index = self.context.portal_atct.getIndex(fieldid) fieldname = index.friendlyName or index.index if selectedItems: html += '<br/><b>%s</b><br/><table>' % (fieldname) for item in selectedItems: name = safe_unicode(item) item = str( component.queryUtility(IURLNormalizer).normalize(name)) value = '' if fieldid in currentValues \ and item in currentValues[fieldid]: value = currentValues[fieldid][item] html += """<tr><td>%s </td><td> <input type="text" size="10" name="%s:record" value="%s" class="colorinput" style="background-color:%s;" /> </td></tr>""" % (name, self.name + '.' + fieldid + '.' + item, value, value) html += '</table>' calendar = ISolgemaFullcalendarProperties(self.context, None) gcalSourcesAttr = getattr(calendar, 'gcalSources', '') if gcalSourcesAttr != None: gcalSources = gcalSourcesAttr.split('\n') if gcalSources: html += '<br/><b>%s</b><br/><table>' % ( _('Google Calendar Sources')) fieldid = 'gcalSources' for i in range(len(gcalSources)): url = gcalSources[i] item = 'source' + str(i) value = '' if fieldid in currentValues \ and item in currentValues[fieldid]: value = currentValues[fieldid][item] html += """<tr><td><span title="%s">%s</span> </td></td><td> <input type="text" size="10" name="%s:record" value="%s" class="colorinput" style="background-color:%s;" /> </td></tr>""" % (str(url), 'Source ' + str(i + 1), self.name + '.' + fieldid + '.' + item, value, value) html += '</table>' availableSubFolders = getattr(calendar, 'availableSubFolders', []) if IATFolder.providedBy(self.context) and availableSubFolders: html += '<br/><b>%s</b><br/><table>' % (_('Sub-Folders')) fieldid = 'subFolders' for folderId in availableSubFolders: value = '' if fieldid in currentValues \ and folderId in currentValues[fieldid]: value = currentValues[fieldid][folderId] html += """<tr><td><span title="%s">%s</span> </td></td><td> <input type="text" size="10" name="%s:record" value="%s" class="colorinput" style="background-color:%s;" /> </td></tr>""" % (folderId, folderId, self.name + '.' + fieldid + '.' + folderId, value, value) html += '</table>' return html
def searchMembers(self, search_param, search_term): """ Search the membership """ mdtool = queryUtility(IMemberDataTool) if mdtool is not None: return mdtool.searchMemberData(search_param, search_term) return None
def test_ct_notiz_schema(self): fti = queryUtility(IDexterityFTI, name='Notiz') schema = fti.lookupSchema() self.assertEqual(INotiz, schema)
def get_portal_type_name_string(obj): """Returns the klass-attribute of the fti.""" fti = queryUtility(IDexterityFTI, name=obj.portal_type) if not fti: return False return fti.klass
def test_factory(self): fti = queryUtility(IDexterityFTI, name='Event') factory = fti.factory obj = createObject(factory) self.assertTrue(IEvent.providedBy(obj))
def test_ct_notiz_fti(self): fti = queryUtility(IDexterityFTI, name='Notiz') self.assertTrue(fti)
def test_schema(self): fti = queryUtility(IDexterityFTI, name='Event') schema = fti.lookupSchema() self.assertEqual(IEvent, schema)
def _makeOne(self): from zope.component import queryUtility from plone.i18n.locales.interfaces import ICountryAvailability return queryUtility(ICountryAvailability)
def test_fti(self): fti = queryUtility(IDexterityFTI, name=constants.CT_DCAT_CATALOG) self.assertTrue(fti)
def test_fti(self): fti = queryUtility(IDexterityFTI, name='Event') self.assertTrue(fti)
def test_schema(self): fti = queryUtility(IDexterityFTI, name=constants.CT_DCAT_CATALOG) schema = fti.lookupSchema() self.assertEqual(IDCATCatalog, schema)
def test_factory(self): fti = queryUtility(IDexterityFTI, name=constants.CT_DCAT_CATALOG) factory = fti.factory obj = createObject(factory) self.assertTrue(IDCATCatalog.providedBy(obj))