def _purgePortlets(self):
        """Unregister all portlet managers and portlet types, and remove
        portlets assigned to the site root
        """

        # Purge portlet types

        registeredPortletTypes = [r.name for r in self.context.registeredUtilities()
                                        if r.provided == IPortletType]

        for name, portletType in getUtilitiesFor(IPortletType):
            if name in registeredPortletTypes:
                self.context.unregisterUtility(provided=IPortletType, name=name)

        # Purge portlets assigned to the site root
        site = self.environ.getSite()

        for name, portletManager in getUtilitiesFor(IPortletManager):
            assignable = queryMultiAdapter((site, portletManager), IPortletAssignmentMapping)
            if assignable is not None:
                for key in list(assignable.keys()):
                    del assignable[key]

        # Purge portlet manager registrations - this will also get rid of
        # global portlet registrations, since these utilities disappear

        portletManagerRegistrations = [r for r in self.context.registeredUtilities()
                                        if r.provided.isOrExtends(IPortletManager)]

        for registration in portletManagerRegistrations:
            self.context.unregisterUtility(provided=registration.provided,
                                           name=registration.name)

    def roles(self):
        """Get a list of roles that can be managed.
        
        Returns a list of dics with keys:
        
            - id
            - title
        """
        context = aq_inner(self.context)
        portal_membership = getToolByName(context, 'portal_membership')
        
        pairs = []

        #check to see if OpenOCW installed
        portal_setup = self.aq_parent.portal_setup
        if 'openOCW-final' in portal_setup.getImportStepRegistry().listSteps():
            #user default sharing page roles
            for name, utility in getUtilitiesFor(ISharingPageRole):
                permission = utility.required_permission
                if permission is None or portal_membership.checkPermission(permission, context):
                    pairs.append(dict(id = name, title = utility.title))
        else:
            #use eduCommons sharing page roles
            for name, utility in getUtilitiesFor(IeduCommonsSharingPageRole):
                permission = utility.required_permission
                if permission is None or portal_membership.checkPermission(permission, context):
                    pairs.append(dict(id = name, title = utility.title))

        pairs.sort(lambda x, y: cmp(x['id'], y['id']))
        return pairs

    def _apply_digest(self, site, storage, digest_info):
        """Filter digest info using registered filters
           apply registered strategies for user with filtered info
        """
        filter_rules = [r[1] for r in getUtilitiesFor(IDigestFilterRule)]
        digest_strategies = [r[1] for r in getUtilitiesFor(IDigestAction)]

        for subscriber, info in digest_info.items():
            for rule in filter_rules:
                info = rule(site, subscriber, info)

            for action in digest_strategies:
                action(site, storage, subscriber, info)

 def getData(self):
     data = dict()
     data["Report Date"] = datetime.utcnow().isoformat()
     for name, utilClass in getUtilitiesFor(ICallHomeCollector):
         chData = utilClass().generateData()
         if chData:
             data.update(chData)
     if self._master:
         for name, utilClass in getUtilitiesFor(IMasterCallHomeCollector):
             chData = utilClass().generateData(self._dmd)
             if chData:
                 data.update(chData)
     return data

def _signalToContextDict(signal, zopeurl, notification=None, guidManager=None):
    summary = signal.event
    # build basic event context wrapper for notifications
    if signal.clear:
        # aged and closed events have clear == True, but they don't have an associated clear event
        #   spoof a clear event in those cases, so the notification messages contain useful info
        if summary.status == zep_pb2.STATUS_AGED:
            occur = signal.clear_event.occurrence.add()
            occur.summary = "Event aging task aged out the event."
            summary.cleared_by_event_uuid = "Event aging task"
        elif summary.status == zep_pb2.STATUS_CLOSED:
            occur = signal.clear_event.occurrence.add()
            
            # once an event is in a closed state, the ownerid (current_user_name) is removed
            # determine who closed the event by extracting the most recent user_name in the event's audit_log
            last_audit_entry = max(signal.event.audit_log, key=lambda x:x.timestamp)
            summary.current_user_name = last_audit_entry.user_name
            
            occur.summary = "User '" + summary.current_user_name + "' closed the event in the Zenoss event console."
            summary.cleared_by_event_uuid = "User action"
        data = NotificationEventContextWrapper(summary, signal.clear_event)
    else:
        data = NotificationEventContextWrapper(summary)

    # add urls to event context
    data['urls']['eventUrl'] = getEventUrl(zopeurl, summary.uuid)
    data['urls']['ackUrl'] = getAckUrl(zopeurl, summary.uuid)
    data['urls']['closeUrl'] = getCloseUrl(zopeurl, summary.uuid)
    proxy = EventSummaryProxy(summary)
    data['urls']['deviceUrl'] = _getBaseDeviceUrl(zopeurl, proxy.DeviceClass, proxy.device)
    data['urls']['eventsUrl'] = getEventsUrl(zopeurl, proxy.DeviceClass, proxy.device)
    data['urls']['reopenUrl'] = getReopenUrl(zopeurl, summary.uuid)
    data['urls']['baseUrl'] = zopeurl
    # now process all custom processors that might be registered to enhance
    # the event context
    for key, processor in getUtilitiesFor(IProcessSignal):
        data[key] = processor.process(signal)

    # Process INotificationContextProvider
    for key, contextProvider in getUtilitiesFor(INotificationContextProvider):
        contextProvider.updateContext(signal, data)

    # Add trigger and notification info
    if notification:
        data['notification']['name'] = notification.titleOrId()
    if guidManager:
        trigger = guidManager.getObject(signal.trigger_uuid)
        if trigger:
            data['trigger']['name'] = trigger.titleOrId()

    return data

def nonfolderish_possible_descriptors(context):
    portal_type = getattr(aq_inner(context), 'portal_type', None)
    if portal_type is None:
        return PossibleDescriptors()

    all = getUtilitiesFor(\
          interfaces.IContentTypeDescriptor)
    all = set([(n, c) for n, c in all])
    folderish = getUtilitiesFor(\
          interfaces.IFolderishContentTypeDescriptor)
    folderish = set([(n, c) for n, c in folderish])

    return PossibleDescriptors(list(all.difference(folderish)),
                               'nonfolderish')

def connect_all(event=None):
    """Connect all connections, which have related utilities registered"""

    # Notify all, who want to register callbacks for connections
    notify(BeforeBrokerConnectEvent())

    # Gather all producer and consumer utility registrations
    from collective.zamqp.interfaces import IProducer, IConsumer
    regs = list(getUtilitiesFor(IProducer)) + list(getUtilitiesFor(IConsumer))

    # Connect all connections, which have related utilities registered
    for connection_id, connection in getUtilitiesFor(IBrokerConnection):
        if filter(lambda reg: reg[1].connection_id == connection_id, regs):
            connection.connect()

    def test_provideConnection(self):

        conns = list(getUtilitiesFor(IZopeDatabaseAdapter))
        self.assertEqual(conns, [])
        connectionstub = queryUtility(IZopeDatabaseAdapter, 'stub')
        self.assertEqual(connectionstub, None)

        self.context = xmlconfig.file("rdb.zcml", zope.rdb.tests)
        connectionstub = queryUtility(IZopeDatabaseAdapter, 'stub')
        connection = connectionstub()
        self.assertEqual(connectionstub.__class__, DAStub)
        conns = getUtilitiesFor(IZopeDatabaseAdapter)
           
        self.assertEqual([c[0] for c in conns], ["stub"])
        self.assertEqual(connection.__class__, ZopeConnection)

def get_nsmap():
    schema_metadata_handlers = tuple(
        getUtilitiesFor(ISchemaMetadataHandler)
    )
    field_metadata_handlers = tuple(
        getUtilitiesFor(IFieldMetadataHandler)
    )

    nsmap = {}
    metadata_handlers = schema_metadata_handlers + field_metadata_handlers
    for name, handler in metadata_handlers:
        namespace, prefix = handler.namespace, handler.prefix
        if namespace is not None and prefix is not None:
            nsmap[prefix] = namespace
    return nsmap

    def roles(self):
        """Get a list of roles that can be managed.

        Returns a list of dicts with keys:

            - id
            - title
        """
        context = self.context
        portal_membership = getToolByName(context, 'portal_membership')

        pairs = []

        for name, utility in getUtilitiesFor(ISharingPageRole):
            permission = utility.required_permission
            if permission is not None:
                if not portal_membership.checkPermission(permission, context):
                    continue
            # be friendly to utilities implemented without required_interface
            iface = getattr(utility, 'required_interface', None)
            if iface is not None and not iface.providedBy(context):
                continue
            pairs.append(dict(id = name, title = utility.title))

        pairs.sort(key=lambda x: normalizeString(translate(x["title"], context=self.request)))
        return pairs

    def listContentTypes(self):
        cts = []
        for name, ct in getUtilitiesFor(ISchemaAware):
            cts.append((ct.title, ct))

        cts.sort()
        return [ct for _t, ct in cts]

 def get_delivery_services(self):
     result = atapi.DisplayList()
     result.add(u'mailhost', _(u'EasyNewsletter_label_PloneMailHost', u'Default Plone Mailhost'))
     for utility in getUtilitiesFor(IMailHost):
         if utility[0]:
             result.add(utility[0], utility[0])
     return result

 def get(self, section, name=None):
     utils = getUtilitiesFor(IConfiguration)
     for utilid, util in utils:
         if utilid:
             res = util.get(section, name)
             if res:
                 return res

def principalInfoStorages(context):
    terms = []
    for name, storage in getUtilitiesFor(IPrincipalInfoStorage):
        terms.append((storage.name, SimpleTerm(name, name, storage.name)))

    terms.sort()
    return SimpleVocabulary([term for n, term in terms])

def quizz_choice(context):
    terms = []
    utils = getUtilitiesFor(IQuizz)
    for name, quizz in utils:
        if check_quizz(name, quizz, context):
            terms.append(SimpleTerm(value=name, title=quizz.__title__))
    return SimpleVocabulary(terms)

    def initialize(self, context, request):
        """ called by the API Framework
        """
        logger.info("DefaultRouter.initialize: context=%r request=%r" % (context, request))

        self.context = context
        self.request = request

        self.environ = request.environ
        self.http_host = request["HTTP_HOST"]
        self.url = request.getURL()

        if self.is_initialized:
            return

        logger.info("DefaultRouter::initialize")
        for name, provider in component.getUtilitiesFor(IRouteProvider):
            logger.info("DefaultRouter::initialize: name=%s, provider=%r", name, provider)

            if getattr(provider, "initialize", None):
                provider.initialize(context, request)

            for route in provider.routes:
                self.add_url_rule(*route)

        self.is_initialized = True

    def guessBody(self, table, header, output):
        """ Discover column types from table body
        """
        utilities = getUtilitiesFor(IGuessType)
        utilities = sorted(utilities, cmp=compare)

        missing = self.missing

        for row in table:
            for index, cell in enumerate(row):
                # Skip missing values
                if cell.lower().strip() in missing:
                    continue

                label = header[index]
                title, columnType = self.column_type(label)

                # Type in header, skip this column
                if columnType:
                    continue

                output.setdefault(title, {})
                for name, guess in utilities:
                    if guess(cell, label):
                        output[title].setdefault(name, guess.priority)
                        output[title][name] += 1

 def show_quickupload_action(self):
     portal = getUtility(IPloneSiteRoot)
     qup_prefs = IQuickUploadControlPanel(portal)
     if not qup_prefs.show_upload_action:
         return False
     context_state = getMultiAdapter(
         (aq_inner(self.context), self.request),
         name=u'plone_context_state')
     if not (
             context_state.is_default_page() or
             context_state.is_folderish()):
         return False
     # If the Quickuploader portlet is shown in the current context, don't
     # show the Upload action, since the portlet takes precedence
     portlet_managers = [
         x[1] for x in getUtilitiesFor(IPortletManager)
         if not x[0].startswith('plone.dashboard')
     ]
     for mgr in portlet_managers:
         retriever = getMultiAdapter((self.context, mgr), IPortletRetriever)
         portlets = retriever.getPortlets()
         for portlet in portlets:
             if IQuickUploadPortlet.providedBy(portlet["assignment"]):
                 return False
     return True

 def items(self):
     results = [(name, TypeInterface(iface, self, name))
                for name, iface in getUtilitiesFor(IInterface)
                if iface.extends(IInterface)]
     results.sort(lambda x, y: cmp(x[1].interface.getName(),
                                   y[1].interface.getName()))
     return results

    def update_vocabulary(self, vocab):
        site = getSite()
        path = '/'.join(vocab.getPhysicalPath())
        logger.info("Updating dynamic vocabulary: %s" % path)

        vocab_id = vocab.vocabulary_id

        registered_vocabs = [i[0] for i in getUtilitiesFor(IVocabularyFactory)]

        if not vocab_id:
            logger.warn(
                "This vocabulary was not registered, you need to register "
                "it first."
            )
            return False

        elif vocab_id not in registered_vocabs:
            logger.warn("There is no vocabulary registered with id: %s"
                        % vocab_id)
            return False

        vocabulary = queryUtility(IVocabularyFactory, vocab_id, context=site)

        vocabulary.clearTerms()

        for child in vocab.getChildNodes():
            vocabulary.addTerm(child)

        sm = site.getSiteManager()
        sm.registerUtility(vocabulary, IVocabularyFactory, vocab_id)
        logger.info("Vocabulary updated.")

        return True