Python component.getUtilitiesFor函数代码示例

    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)