def cities(self, context):

        root = zapi.getUtility(Products.CMFPlone.interfaces.IPloneSiteRoot)
        cat = root.portal_catalog
        results = []
        keys = []
        
        ## All cities
        
        allcities_util = zapi.getUtility(ISwissCities)
        allcities = allcities_util.cities()
        #print allcities
        allcities_dict = dict(allcities)
        
        # Contextualize the list
        brains = cat({'portal_type': ['JubinStationPartner','JubinRestaurantPartner','JubinCommercialPartner',],
                      'path': '/'.join(context.getPhysicalPath())
                      })
                      
        for brain in brains:
            obj = brain.getObject()
            city_key = obj.city
            if city_key in keys:
                continue
            keys.append(city_key)
        
        # Now build the list of key/value pairs
        for k in keys:
            v = allcities_dict.get(k, '')
            if v:
                results.append((k, v))

        results = sorted(results,key=operator.itemgetter(0))
        return results

    def test_nestedSitesDontConflictButStillAcquire(self):
        # let's register a dummy utility in the dummy site
        dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, dummy)

        # let's also create a subsite and make that our site
        manage_addDummySite(self.folder.site, 'subsite')
        enableLocalSiteHook(self.folder.site.subsite)
        setSite(self.folder.site.subsite)

        # we should still be able to lookup the original utility from
        # the site one level above
        self.assertEqual(zapi.getUtility(IDummyUtility), dummy)

        # now we register a dummy utility in the subsite and see that
        # its registration doesn't conflict
        subdummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, subdummy)

        # when we look it up we get the more local one now because the
        # more local one shadows the less local one
        self.assertEqual(zapi.getUtility(IDummyUtility), subdummy)

        # getAllUtilitiesFor gives us both the more local and the less
        # local utility (XXX not sure if this is the right semantics
        # for getAllUtilitiesFor)
        self.assertEqual(sets.Set(zapi.getAllUtilitiesRegisteredFor(IDummyUtility)),
                         sets.Set([subdummy, dummy]))

        # getUtilitiesFor will only find one, because the more local
        # one shadows the less local one
        self.assertEqual(list(zapi.getUtilitiesFor(IDummyUtility)),
                         [('', subdummy)])

    def test_getNextUtility(self):
        # test local site vs. global site
        global_dummy = DummyUtility()
        provideUtility(global_dummy, IDummyUtility)

        local_dummy = DummyUtility()
        sm = getSiteManager()
        sm.registerUtility(IDummyUtility, local_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

        # test local site vs. nested local site
        manage_addDummySite(self.folder.site, 'subsite')
        import warnings
        showwarning = warnings.showwarning
        warnings.showwarning = lambda *a, **k: None
        enableLocalSiteHook(self.folder.site.subsite)
        warnings.showwarning = showwarning

        sublocal_dummy = DummyUtility()
        sm = getSiteManager()
        sm.registerUtility(IDummyUtility, sublocal_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), sublocal_dummy)
        self.assertEquals(getNextUtility(self.folder.site.subsite, IDummyUtility),
                          local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

    def test_getNextUtility(self):
        # test local site vs. global site
        global_dummy = DummyUtility()
        provideUtility(global_dummy, IDummyUtility)

        local_dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, local_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

        # test local site vs. nested local site
        manage_addDummySite(self.folder.site, 'subsite')
        enableLocalSiteHook(self.folder.site.subsite)
        setSite(self.folder.site.subsite)

        sublocal_dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, sublocal_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), sublocal_dummy)
        self.assertEquals(getNextUtility(self.folder.site.subsite, IDummyUtility),
                          local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

 def __init__(self, context, request):
     super(SiteManagementView, self).__init__(context, request)
     if 'activeTool' in request:
         request.response.setCookie('SetActiveTool', request['activeTool'],
                                    path="/")
         self.activeTool = zapi.getUtility(IToolConfiguration,
                                           request['activeTool'])
     elif 'SetActiveTool' in request:
         self.activeTool = zapi.getUtility(IToolConfiguration,
                                           request['SetActiveTool'])

    def test_registerTwoUtilitiesWithSameNameDifferentInterface(self):
        sm = zapi.getSiteManager()
        self.failUnless(IRegisterUtilitySimply.providedBy(sm))
        dummy = DummyUtility()
        superdummy = DummyUtility()
        directlyProvides(superdummy, ISuperDummyUtility)
        sm.registerUtility(IDummyUtility, dummy, 'dummy')
        sm.registerUtility(ISuperDummyUtility, superdummy, 'dummy')

        self.assertEquals(zapi.getUtility(IDummyUtility, 'dummy'), dummy)
        self.assertEquals(zapi.getUtility(ISuperDummyUtility, 'dummy'),
                          superdummy)

 def install(self):
     tool_names = self.request['selected']
     for tool_name in tool_names:
         self.activeTool = zapi.getUtility(IToolConfiguration, tool_name)
         type_name = list(self.addingInfo())[0]['extra']['factory']
         self.action(type_name)
     self.activeTool = None

    def action(self, type_name='', id=''):
        if not type_name:
            raise UserError("You must select the type of object to add.")

        if type_name.startswith('@@'):
            type_name = type_name[2:]

        if '/' in type_name:
            view_name  = type_name.split('/', 1)[0]
        else:
            view_name = type_name

        if zapi.queryView(self, view_name, self.request) is not None:
            url = "%s/%s=%s" % (
                zapi.getMultiAdapter((self, self.request), name=u"absolute_url"),
                type_name, id)
            self.request.response.redirect(url)
            return

        if not self.contentName:
            self.contentName = id

        factory = zapi.getUtility(IFactory, type_name)
        content = factory()

        notify(ObjectCreatedEvent(content))
        self.add(content)
        self.request.response.redirect(self.nextURL())

    def addingInfo(self):
        """Return menu data.

        This is sorted by title.
        """
        container = self.context
        menu_service = zapi.getService("BrowserMenu")
        result = []
        for menu_id in (self.menu_id, 'zope.app.container.add'):
            if not menu_id:
                continue
            for item in menu_service.getMenu(menu_id, self, self.request):
                extra = item.get('extra')
                if extra:
                    factory = extra.get('factory')
                    if factory:
                        factory = zapi.getUtility(IFactory, factory)
                        if not checkFactory(container, None, factory):
                            continue
                        elif item['extra']['factory'] != item['action']:
                            item['has_custom_add_view']=True
                result.append(item)

        result.sort(lambda a, b: cmp(a['title'], b['title']))
        return result

 def setCacheId(self, id):
     # Remove object from old cache
     old_cache_id = self.getCacheId()
     if old_cache_id and old_cache_id != id:
         cache = zapi.getUtility(ICache, old_cache_id)
         cache.invalidate(self._context)
     annotations = IAnnotations(removeAllProxies(self._context))
     annotations[annotation_key] = id

 def get_thesaurus(self):
     """ return the content for a particular thesurus """
     from zopyx.txng3.core.interfaces import IThesaurus
     try:
         from zope.app import zapi
         return zapi.getUtility(IThesaurus, self.request['id'])
     except ImportError:
         from zope.component import getUtility
         return getUtility(IThesaurus, self.request['id'])

def getCacheForObject(obj):
    """Returns the cache associated with `obj` or ``None``."""
    adapter = ICacheable(obj, None)
    if adapter is None:
        return None
    cache_id = adapter.getCacheId()
    if not cache_id:
        return None
    return zapi.getUtility(ICache, cache_id)

    def test_registerUtilityOnUtilityRegistry(self):
        utils = zapi.getSiteManager().utilities
        dummy = DummyUtility()
        utils.registerUtility(IDummyUtility, dummy, 'dummy')

        self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
        self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                          [('dummy', dummy)])
        self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
            IDummyUtility)), [dummy])

    def __call__(self, *args):
        site  = getObject(self.context)
        #sm = site.getSiteManager()
        setSite(site)

        # blogger product
        blogger = getUtility(IBloggerProduct)
        if not blogger.__installed__:
            blogger.install()

        # set wysiwyg editor
        configlet = getUtility(IContentEditorConfiglet)
        configlet.default_editor = 'tinymce'
        notify(ObjectModifiedEvent(configlet))

        # set skin
        skintool = getUtility(ISkinTool)
        skintool.skin = 'quick.theme.sample'
        notify(ObjectModifiedEvent(skintool))