Exemplo n.º 1
0
def decorate_external_object(
        do_decorate,
        call_if_not_decorate,
        decorate_interface,
        decorate_meth_name,
        original_object,
        external_object,
        registry,  # legacy, ignored. pylint:disable=unused-argument
        request):
    if do_decorate:
        for decorator in subscribers((original_object, ), decorate_interface):
            meth = getattr(decorator, decorate_meth_name)
            meth(original_object, external_object)

        if request is NotGiven:
            request = get_current_request()

        if request is not None:
            # Request specific decorating, if given, is more specific than plain object
            # decorating, so it gets to go last.
            for decorator in subscribers((original_object, request),
                                         decorate_interface):
                meth = getattr(decorator, decorate_meth_name)
                meth(original_object, external_object)
    elif call_if_not_decorate is not NotGiven and call_if_not_decorate is not None:
        # XXX: This makes no sense. What is this argument even for?
        call_if_not_decorate(original_object, external_object)

    return external_object
Exemplo n.º 2
0
    def validate(self, REQUEST=None, errors=None, data=None, metadata=None):
        """Validates the form data from the request.
        """
        if errors is None:
            errors = {}

        self.pre_validate(REQUEST, errors)

        for pre_validator in subscribers((self,), IObjectPreValidation):
            pre_errors = pre_validator(REQUEST)
            if pre_errors is not None:
                for field_name, error_message in pre_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        if errors:
            return errors
        self.Schema().validate(instance=self, REQUEST=REQUEST,
                               errors=errors, data=data, metadata=metadata)

        self.post_validate(REQUEST, errors)

        for post_validator in subscribers((self,), IObjectPostValidation):
            post_errors = post_validator(REQUEST)
            if post_errors is not None:
                for field_name, error_message in post_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        return errors
Exemplo n.º 3
0
    def validate(self, REQUEST=None, errors=None, data=None, metadata=None):
        """Validates the form data from the request.
        """
        if errors is None:
            errors = {}

        self.pre_validate(REQUEST, errors)

        for pre_validator in subscribers((self,), IObjectPreValidation):
            pre_errors = pre_validator(REQUEST)
            if pre_errors is not None:
                for field_name, error_message in pre_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        if errors:
            return errors
        self.Schema().validate(instance=self, REQUEST=REQUEST,
                               errors=errors, data=data, metadata=metadata)

        self.post_validate(REQUEST, errors)

        for post_validator in subscribers((self,), IObjectPostValidation):
            post_errors = post_validator(REQUEST)
            if post_errors is not None:
                for field_name, error_message in post_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        return errors
Exemplo n.º 4
0
    def validate(self):
        """
        Will walk through all subscribers from IValidator type
        the first one will be returned as valid type. In this way we can supporting a lot of types
        on the same port/service

        :return: matched IValidator subscriber
        """

        for sub in subscribers([self.__msg], IValidator):

            msg = sub.validate()

            self.is_valid = msg.is_valid
            self.message_type = msg.message_type
            self.message = msg.message

            # we want only one correct type of our message so
            # only one validator will response with True

            if self.is_valid is True:

                self.__logger.debug('Matched type is: {}'.format(
                    self.message_type))

                return self

        self.__logger.warning(
            'Main Validator - There are no subscribers from type IValidator')

        return False
Exemplo n.º 5
0
def applyChanges(context, form_fields, data, adapters=None):
    if adapters is None:
        adapters = {}

    changed = False

    for form_field in form_fields:
        field = form_field.field
        # Adapt context, if necessary
        interface = field.interface
        adapter = adapters.get(interface)
        if adapter is None:
            if interface is None:
                adapter = context
            else:
                adapter = interface(context)
            adapters[interface] = adapter

        name = form_field.__name__
        newvalue = data.get(name, form_field) # using form_field as marker
        if (newvalue is not form_field) and (field.get(adapter) != newvalue):
            changed = True
            field.set(adapter, newvalue)
            for handler in component.subscribers(
                (adapter, field), IFieldUpdate
                ):
                handler.update()

    return changed
 def _process_devices(self):
     stats = {'Device Count': 0,
              'Decommissioned Devices': 0,
              'CPU Cores':0}
     LINKED_DEVICES = "Linked Devices"
     if LINKED_DEVICES not in stats:
         stats[LINKED_DEVICES] = 0
     for device in self._dmd.Devices.getSubDevicesGen_recursive():
         stats['Device Count'] += 1
         if device.productionState < 0:
             stats["Decommissioned Devices"] += 1
         cpuCount = IDeviceCpuCount(device).cpuCount()
         log.debug("Devices %s has %s cpu cores", device, cpuCount)
         stats['CPU Cores'] += cpuCount
         for adapter in subscribers([device], IDeviceResource):
             adapter.processDevice(stats)
         found_linked = False
         for name, adapter in getAdapters((device,), IDeviceLink):
             if adapter.linkedDevice():
                 key = "%s - %s" % (LINKED_DEVICES, name)
                 if key not in stats:
                     stats[key] = 0
                 stats[key] += 1
                 if not found_linked:
                     stats[LINKED_DEVICES] += 1
                     found_linked = True
                 
             
     return stats
Exemplo n.º 7
0
    def __iter__(self):
        for item in self.previous:
            keys = list(item.keys())
            typekey = self.typekey(*keys)[0]
            pathkey = self.pathkey(*keys)[0]

            # integrazione check del tipo all'interno di questo ciclo
            skip = False
            for excluded_type in getattr(self, "exclude_type", []):
                if skip:
                    break
                # if item is in a blacked-list type, skip it
                for parent_type in item.get("parents_type_list", []):
                    if parent_type == excluded_type:
                        skip = True
                        break
                    if skip:
                        break
                # check obj type
                if item.get("_type", None):
                    if item["_type"] == excluded_type:
                        skip = True
            if skip:
                if item.get("_uid") in self.items_in:
                    self.items_in[item.get(
                        "_uid")]["reason"] = "Skipped portal_type"
                else:
                    self.items_in[item.get("_uid")] = {
                        "id": item.get("_id"),
                        "portal_type": item[typekey],
                        "title": item.get("title"),
                        "path": item.get("_path"),
                    }
                continue

            if not (typekey and pathkey):
                logger.warning("Not enough info for item: {0}".format(item))
                yield item
                continue
            # custom types mappings
            handlers = [
                x for x in subscribers((
                    self.context, self.context.REQUEST), IPortalTypeMapping)
            ]
            for handler in sorted(handlers, key=lambda h: h.order):
                item = handler(item=item, typekey=typekey)
            if item.get("skipped", False):
                if item.get("_uid") in self.items_in:
                    self.items_in[item.get("_uid")]["reason"] = item.get(
                        "skipped_message", "")
                else:
                    self.items_in[item.get("_uid")] = {
                        "id": item.get("_id"),
                        "portal_type": item[typekey],
                        "title": item.get("title"),
                        "path": item.get("_path"),
                    }
                continue

            yield item
    def __call__(self, context):

        results = []
        group_properties = dict()
        groups = api.group.get_groups()

        # Fix context if you are using the vocabulary in DataGridField.
        # See https://github.com/collective/collective.z3cform.datagridfield/issues/31:  # NOQA: 501
        if not IDexterityContent.providedBy(context):
            req = getRequest()
            context = req.PARENTS[0]

        for group in groups:
            group_id = group.getId()
            group_properties[group_id] = {
                "title": group.getGroupTitleOrName(),
                "email": group.getProperty("email"),
            }
        results = [(id, property["title"])
                   for id, property in group_properties.items()]

        # run registered group filter:
        for subscriber in subscribers([self], IReceiversGroupFilter):
            results = subscriber.filter(results)

        # create a list of SimpleTerm items:
        terms = []
        for item in results:
            terms.append(
                SimpleTerm(value=item[0], token=item[0], title=item[1]))
        # Create a SimpleVocabulary from the terms list and return it:
        return SimpleVocabulary(terms)
Exemplo n.º 9
0
    def check(self):

        """
        Will trying to get a RootAPI and if match one will fired a process_factory
        of an implementation API

        :return: False if not success otherwise the response from process_factory
        """
        for api in subscribers([self.comp], IJSONResourceRootAPI):

            if api.__class__.__name__.lower() in self.comp.to_dict().keys():

                self.__logger.debug('Candidate API {} for {}'.format(
                    api.__class__.__name__,
                    self.comp.__class__.__name__
                ))

                self.__logger.info('Successful apply API {} for {}'.format(
                    api.__class__.__name__,
                    self.comp.__class__.__name__
                ))

                return api.process_factory()

        return False
Exemplo n.º 10
0
 def __call__(self):
     new_user = IUser(self.request)
     checks = component.subscribers((new_user,), IRedundancyCheck)
     if any([check.check(new_user, self.request) for check in checks]) or\
        not self.context.insert(new_user, check_member=True):
         return exception_response(409)
     return HTTPCreated()
Exemplo n.º 11
0
    def getSubItems(self, context):
        """Collect all items that should be displayed in the submenu of context.

        Submenu items are registered as subscribers with interface
        ISubMenuItem.
        """
        return list(subscribers((context, ), ISubMenuItem))
Exemplo n.º 12
0
def transform_obj(target):
    while True:
        oid, obj = (yield)

        # First, get any subscription adapters registered as transforms
        adapters = subscribers((obj, ), IInvalidationOid)
        # Next check for an old-style (regular adapter) transform
        try:
            adapters = chain(adapters, (IInvalidationOid(obj), ))
        except TypeError:
            # No old-style adapter is registered
            pass
        transformed = set()
        for adapter in adapters:
            o = adapter.transformOid(oid)
            if isinstance(o, str):
                transformed.add(o)
            elif hasattr(o, '__iter__'):
                # If the transform didn't give back a string, it should have
                # given back an iterable
                transformed.update(o)
        # Get rid of any useless Nones
        transformed.discard(None)
        # Get rid of the original oid, if returned. We don't want to use it IF
        # any transformed oid came back.
        transformed.discard(oid)
        target.send(transformed or (oid, ))
Exemplo n.º 13
0
def impacts_for(thing):
    '''
    Return a two element tuple.

    First element is a list of object ids impacted by thing. Second element is
    a list of object ids impacting thing.
    '''
    try:
        from ZenPacks.zenoss.Impact.impactd.interfaces import \
            IRelationshipDataProvider

    except ImportError:
        return ([], [])

    impacted_by = []
    impacting = []

    guid_manager = IGUIDManager(thing.getDmd())
    for subscriber in subscribers([thing], IRelationshipDataProvider):
        for edge in subscriber.getEdges():
            source = guid_manager.getObject(edge.source)
            impacted = guid_manager.getObject(edge.impacted)
            if source == thing:
                impacted_by.append(impacted.id)
            elif impacted == thing:
                impacting.append(source.id)

    return (impacted_by, impacting)
def impacts_for(thing):
    '''
    Return a two element tuple.

    First element is a list of object ids impacted by thing. Second element is
    a list of object ids impacting thing.
    '''
    from ZenPacks.zenoss.Impact.impactd.interfaces \
        import IRelationshipDataProvider

    impacted_by = []
    impacting = []

    guid_manager = IGUIDManager(thing.getDmd())
    for subscriber in subscribers([thing], IRelationshipDataProvider):
        for edge in subscriber.getEdges():
            source = guid_manager.getObject(edge.source)
            impacted = guid_manager.getObject(edge.impacted)

            if source.id == thing.id:
                impacted_by.append(impacted.id)
            elif impacted.id == thing.id:
                impacting.append(source.id)

    return (impacted_by, impacting)
Exemplo n.º 15
0
def dispatchToComponent(registration, event):
    """When a utility is registered, dispatch to an event handler registered for
    the particular component registered, the registration and the event.
    """
    handlers = subscribers((registration.component, registration, event), None)
    for handler in handlers:
        pass  # getting them does the work
Exemplo n.º 16
0
    def deserialize_data(self, data):
        for root in data:
            for tab in root.get("items", []):
                for key in KEYS_WITH_URL:
                    value = tab.get(key, [])
                    if value:
                        tab[key] = [
                            x.get("UID", "") for x in value if x.get("UID", "")
                        ]
                blocks = tab.get("blocks", {})
                if blocks:
                    for id, block_value in blocks.items():
                        block_type = block_value.get("@type", "")
                        handlers = []
                        for h in subscribers(
                            (self.context, self.request),
                            IBlockFieldDeserializationTransformer,
                        ):
                            if (
                                h.block_type == block_type
                                or h.block_type is None  # noqa
                            ):
                                handlers.append(h)
                        for handler in sorted(handlers, key=lambda h: h.order):
                            block_value = handler(block_value)

                        blocks[id] = block_value
        return data
Exemplo n.º 17
0
    def getSubItems(self, context):
        """Collect all items that should be displayed in the submenu of context.

        Submenu items are registered as subscribers with interface
        ISubMenuItem.
        """
        return list(subscribers((context, ), ISubMenuItem))
Exemplo n.º 18
0
    def validate(self):

        """
        Will walk through all subscribers from IValidator type
        the first one will be returned as valid type. In this way we can supporting a lot of types
        on the same port/service

        :return: matched IValidator subscriber
        """

        for sub in subscribers([self.__msg], IValidator):

            msg = sub.validate()

            self.is_valid = msg.is_valid
            self.message_type = msg.message_type
            self.message = msg.message

            # we want only one correct type of our message so
            # only one validator will response with True

            if self.is_valid is True:

                self.__logger.debug('Matched type is: {}'.format(self.message_type))

                return self

        self.__logger.warning('Main Validator - There are no subscribers from type IValidator')

        return False
Exemplo n.º 19
0
    def _process_devices(self):
        stats = {
            'Device Count': 0,
            'Decommissioned Devices': 0,
            'CPU Cores': 0
        }
        LINKED_DEVICES = "Linked Devices"
        if LINKED_DEVICES not in stats:
            stats[LINKED_DEVICES] = 0
        for device in self._dmd.Devices.getSubDevicesGen_recursive():
            stats['Device Count'] += 1
            if device.productionState < 0:
                stats["Decommissioned Devices"] += 1
            cpuCount = IDeviceCpuCount(device).cpuCount()
            log.debug("Devices %s has %s cpu cores", device, cpuCount)
            stats['CPU Cores'] += cpuCount
            for adapter in subscribers([device], IDeviceResource):
                adapter.processDevice(stats)
            found_linked = False
            for name, adapter in getAdapters((device, ), IDeviceLink):
                if adapter.linkedDevice():
                    key = "%s - %s" % (LINKED_DEVICES, name)
                    if key not in stats:
                        stats[key] = 0
                    stats[key] += 1
                    if not found_linked:
                        stats[LINKED_DEVICES] += 1
                        found_linked = True

        return stats
Exemplo n.º 20
0
 def _eventRedispatcher(self, event):
     """This works similar to zope.component.event.objectEventNotify:
     It dispatches object events to subscribers that listen to
     (object, view, event)."""
     adapters = component.subscribers((event.object, self, event), None)
     for adapter in adapters:
         pass # getting them does the work
Exemplo n.º 21
0
def transform_obj(target):
    while True:
        oid, obj = (yield)

        # First, get any subscription adapters registered as transforms
        adapters = subscribers((obj,), IInvalidationOid)
        # Next check for an old-style (regular adapter) transform
        try:
            adapters = chain(adapters, (IInvalidationOid(obj),))
        except TypeError:
            # No old-style adapter is registered
            pass
        transformed = set()
        for adapter in adapters:
            o = adapter.transformOid(oid)
            if isinstance(o, str):
                transformed.add(o)
            elif hasattr(o, '__iter__'):
                # If the transform didn't give back a string, it should have
                # given back an iterable
                transformed.update(o)
        # Get rid of any useless Nones
        transformed.discard(None)
        # Get rid of the original oid, if returned. We don't want to use it IF
        # any transformed oid came back.
        transformed.discard(oid)
        target.send(transformed or (oid,))
Exemplo n.º 22
0
def available_slots(context):
    slots = subscribers([context], IMailchimpSlot)
    return SimpleVocabulary([
        SimpleTerm(value=str(li.name), title=li.name) for li in slots \
                if queryMultiAdapter((context, context.REQUEST),
                                     IMailchimpSlotRenderer, name=li.name)]
    )
Exemplo n.º 23
0
    def publishTraverse(self, request, name):
        view = queryMultiAdapter((self, request), name=name)
        if view is not None:
            if ISaveable.providedBy(view):
                self.saveable = True
            else:
                self.saveable = False

            self.wizard.updateActions()
            return view

        for publisher in subscribers((self, request), IPublisherPlugin):
            try:
                view = publisher.publishTraverse(request, name)
                if ISaveable.providedBy(view):
                    self.saveable = True
                else:
                    self.saveable = False

                self.wizard.updateActions()
                return view
            except NotFound:
                pass

        raise NotFound(self, name, request)
Exemplo n.º 24
0
    def __call__(self, validate_all=False):
        if HAS_PLONE_6:
            # Call the default DX content deserializer
            super().__call__(self)

        data = json_body(self.request)

        if "layout" in data:
            layout = data["layout"]
            self.context.setLayout(layout)

        # Volto Blocks on the Plone Site root faker for Plone 5
        if not HAS_PLONE_6:
            # OrderingMixin (needed for correct ordering for Plone < 6)
            if "ordering" in data and "subset_ids" not in data["ordering"]:
                data["ordering"]["subset_ids"] = self.context.contentIds()
            self.handle_ordering(data)

            if "blocks" in data:
                value = data["blocks"]
                for id, block_value in value.items():
                    block_type = block_value.get("@type", "")
                    handlers = []
                    for h in subscribers(
                        (self.context, self.request),
                            IBlockFieldDeserializationTransformer,
                    ):
                        if h.block_type == block_type or h.block_type is None:
                            handlers.append(h)
                    for handler in sorted(handlers, key=lambda h: h.order):
                        block_value = handler(block_value)
                    value[id] = block_value
                if not getattr(self.context, "blocks", False):
                    self.context.manage_addProperty("blocks",
                                                    json.dumps(value),
                                                    "string")  # noqa
                else:
                    self.context.manage_changeProperties(
                        blocks=json.dumps(value))  # noqa

            if "blocks_layout" in data:
                if not getattr(self.context, "blocks_layout", False):
                    self.context.manage_addProperty("blocks_layout",
                                                    json.dumps(
                                                        data["blocks_layout"]),
                                                    "string")  # noqa
                else:
                    self.context.manage_changeProperties(
                        blocks_layout=json.dumps(
                            data["blocks_layout"]))  # noqa

            if "title" in data:
                self.context.setTitle(data["title"])

            if "description" in data:
                self.context.manage_changeProperties(
                    description=data["description"])  # noqa

        return self.context
Exemplo n.º 25
0
 def apply_handlers(self, item):
     handlers = [
         x for x in subscribers((self.portal,
                                 self.request), IPortalTypeMapping)
     ]
     for handler in sorted(handlers, key=lambda h: h.order):
         item = handler(item=item, typekey="_type")
     return item
Exemplo n.º 26
0
def is_private(ob):
    """
    Do any registered private object adapters define this object as private?
    """
    for adapted in subscribers([ob], IPrivateObjectAdapter):
        if adapted.is_private():
            return True
    return False
Exemplo n.º 27
0
def logger_reporter_for_secret_sniffers(event):
    for sniffer in component.subscribers((event.object, ),
                                         mellon.ISecretSniffer):
        for secret in sniffer:
            wht_lstd = False
            for wht_lst in component.subscribers((secret, ),
                                                 mellon.IWhitelist):
                for wht_lst_info in wht_lst:
                    logger.info(
                        u"skipping white-listed secret: {} because {}".format(
                            secret, wht_lst_info))
                    wht_lstd = True

            if not wht_lstd:
                logging.warn(\
                    u"Found secret in file snippet.  Secret information: [{}]. Snippet information: [{}].  File information: [{}]."\
                    .format(secret, event.object.__name__, event.object.__parent__))
Exemplo n.º 28
0
def queryMultiSubscriptions(components, interface):
    """Query for subscriptions on the `components` providing `interface`.

    :parameter components: tuple of components to lookup the subscription for.
    :parameter interface: interface that the subscriptions should provide.
    :return: a list of subscriptions.
    """
    return component.subscribers(components, interface)
Exemplo n.º 29
0
    def getExportersForSupportedFileFormat(self, file_format):
        """See `ITranslationExporter`."""
        exporters_available = []
        for exporter in subscribers([self], ITranslationFormatExporter):
            if file_format in exporter.supported_source_formats:
                exporters_available.append(exporter)

        return exporters_available
Exemplo n.º 30
0
    def getExportersForSupportedFileFormat(self, file_format):
        """See `ITranslationExporter`."""
        exporters_available = []
        for exporter in subscribers([self], ITranslationFormatExporter):
            if file_format in exporter.supported_source_formats:
                exporters_available.append(exporter)

        return exporters_available
Exemplo n.º 31
0
def queryMultiSubscriptions(components, interface):
    """Query for subscriptions on the `components` providing `interface`.

    :parameter components: tuple of components to lookup the subscription for.
    :parameter interface: interface that the subscriptions should provide.
    :return: a list of subscriptions.
    """
    return component.subscribers(components, interface)
Exemplo n.º 32
0
def is_private(ob):
    """
    Do any registered private object adapters define this object as private?
    """
    for adapted in subscribers([ob], IPrivateObjectAdapter):
        if adapted.is_private():
            return True
    return False
Exemplo n.º 33
0
 def __call__(self):
     metrics = collections.defaultdict(lambda: {})
     for subscriber in component.subscribers((self.context.dmd,), interfaces.ISystemMetric):
         try:
             metrics[subscriber.category].update(subscriber.metrics())
         except Exception as ex:
             _LOG.warn("An error occurred gathering performance stats: %s" % ex)
         
     self.request.response.write(json.dumps(metrics))
Exemplo n.º 34
0
def dispatchToOpaqueItems(ob, event):
    """Dispatch an event to opaque sub-items of a given object.
    """
    for opaque in ob.opaqueValues():
        s = getattr(opaque, '_p_changed', 0)
        for ignored in subscribers((opaque, event), None):
            pass # They do work in the adapter fetch
        if s is None:
            opaque._p_deactivate()
Exemplo n.º 35
0
    def __call__(self):
        self.request.response.content_type = 'application/javascript'

        mapping = dict()
        for mapper in subscribers((self.context, ), IClassPathMapping):
            mapping[mapper.namespace] = IBaseUrl(self.request).url(mapper.path)

        out = json.dumps(mapping, indent=' ' * 4)
        self.request.response.write(CLASS_PATH_MAPPER % out)
        self.request.response.content_type = 'application/javascript'
Exemplo n.º 36
0
    def getExporterProducingTargetFileFormat(self, file_format):
        """See `ITranslationExporter`."""
        for exporter in subscribers([self], ITranslationFormatExporter):
            if (exporter.format == file_format
                    or (file_format == TranslationFileFormat.XPI
                        and exporter.format == TranslationFileFormat.XPIPO)):
                # XPIPO is a special case for XPI exports.
                return exporter

        return None
Exemplo n.º 37
0
 def isVM(self):
     if self._isVM is None:
         self._isVM = False
         for deviceType in subscribers((self._device,), IVirtualDeviceType):
             vmType = deviceType.vmType()
             if vmType is not None:
                 self._vmType = vmType
                 self._isVm = True
                 break
     return self._isVM
Exemplo n.º 38
0
    def providers(self):
        providers = []
        for provider in subscribers([self.context], IExportProvider):
            if provider.layer:
                if not provider.layer.providedBy(self.request):
                    continue

            providers.append(provider)

        return providers
Exemplo n.º 39
0
 def messages(self):
     """Get all messages
     """
     
     messages = []
     for checker in subscribers((self.context,), ISanityChecker):
         new_messages = checker()
         if new_messages:
             messages += new_messages
     return messages
Exemplo n.º 40
0
    def getExporterProducingTargetFileFormat(self, file_format):
        """See `ITranslationExporter`."""
        for exporter in subscribers([self], ITranslationFormatExporter):
            if (exporter.format == file_format or
                (file_format == TranslationFileFormat.XPI and
                 exporter.format == TranslationFileFormat.XPIPO)):
                # XPIPO is a special case for XPI exports.
                return exporter

        return None
Exemplo n.º 41
0
    def __call__(self):
        self.request.response.content_type = 'application/javascript'

        mapping = dict()
        for mapper in subscribers((self.context,), IClassPathMapping):
            mapping[mapper.namespace] = IBaseUrl(self.request).url(mapper.path)

        out = json.dumps(mapping, indent=' ' * 4)
        self.request.response.write(CLASS_PATH_MAPPER % out)
        self.request.response.content_type = 'application/javascript'
Exemplo n.º 42
0
 def isVM(self):
     if self._isVM is None:
         self._isVM = False
         for deviceType in subscribers((self._device,), IVirtualDeviceType):
             vmType = deviceType.vmType()
             if vmType is not None:
                 self._vmType = vmType
                 self._isVm = True
                 break
     return self._isVM
Exemplo n.º 43
0
    def publishTraverse(self, request, name):
        # Look at all the traverser plugins, whether they have an answer.
        for traverser in subscribers((self.context, request),
                                     interfaces.ITraverserPlugin):
            try:
                return traverser.publishTraverse(request, name)
            except NotFound:
                pass

        raise NotFound(self.context, name, request)
Exemplo n.º 44
0
    def messages(self):
        """Get all messages
        """

        messages = []
        for checker in subscribers((self.context, ), ISanityChecker):
            new_messages = checker()
            if new_messages:
                messages += new_messages
        return messages
Exemplo n.º 45
0
    def providers(self):
        providers = []
        for provider in subscribers([self.context], IExportProvider):
            if provider.layer:
                if not provider.layer.providedBy(self.request):
                    continue

            providers.append(provider)

        return providers
Exemplo n.º 46
0
 def scripts_post_migration(self):
     """
     Excecute a series of post migration steps in order
     """
     handlers = [
         x for x in subscribers((self.context,
                                 self.request), IPostMigrationStep)
     ]
     for handler in sorted(handlers, key=lambda h: h.order):
         handler(transmogrifier=self.transmogrifier)
Exemplo n.º 47
0
    def _verifyImport(self, obj):
        adapted = queryAdapter(object(), IAnotherDummyInterface2)
        self.failUnless(IAnotherDummyInterface2.providedBy(adapted))
        self.failUnless(adapted.verify())

        adapted = queryAdapter(object(), IAnotherDummyInterface2, name=u'foo')
        self.failUnless(IAnotherDummyInterface2.providedBy(adapted))
        self.failUnless(adapted.verify())

        dummy = DummyObject()
        results = [
            adap.verify()
            for adap in subscribers([dummy], IAnotherDummyInterface2)
        ]
        self.assertEquals(results, [True])

        dummy = DummyObject()
        handle(dummy)
        self.assertEquals(dummy.handled, 1)

        util = queryUtility(IDummyInterface2, name=u'foo')
        self.failUnless(IDummyInterface.providedBy(util))
        self.failUnless(util.verify())
        self.failUnless(util.__parent__ == obj)
        name = 'Products.GenericSetup.tests.test_components.IDummyInterface2-foo'
        self.assertEquals(util.__name__, name)
        self.failUnless(name in obj.objectIds())

        util = queryUtility(IDummyInterface)
        self.failUnless(IDummyInterface.providedBy(util))
        self.failUnless(util.verify())
        self.failUnless(util.__parent__ == obj)
        name = 'dummy_utility'
        self.assertEquals(util.__name__, name)
        self.failUnless(name in obj.objectIds())

        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(obj.aq_parent, 'dummy_tool')
        self.assertEqual(tool.meta_type, 'dummy tool')
        self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))

        util = queryUtility(IDummyInterface2, name='dummy tool name2')
        self.failUnless(IDummyInterface2.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(obj.aq_parent, 'dummy_tool2')
        self.assertEqual(tool.meta_type, 'dummy tool2')
        self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))
Exemplo n.º 48
0
    def _verifyImport(self, obj):
        adapted = queryAdapter(object(), IAnotherDummy2)
        self.failUnless(IAnotherDummy2.providedBy(adapted))
        self.failUnless(adapted.verify())

        adapted = queryAdapter(object(), IAnotherDummy2, name=u'foo')
        self.failUnless(IAnotherDummy2.providedBy(adapted))
        self.failUnless(adapted.verify())

        dummy = DummyObject()
        results = [adap.verify() for adap in
                        subscribers([dummy], IAnotherDummy2)]
        self.assertEquals(results, [True])

        dummy = DummyObject()
        handle(dummy)
        self.assertEquals(dummy.handled, 1)

        util = queryUtility(IDummyInterface2, name=u'foo')
        self.failUnless(IDummyInterface.providedBy(util))
        self.failUnless(util.verify())
        self.failUnless(util.__parent__ == obj)
        name = ('Products.GenericSetup.tests.test_components.'
                    'IDummyInterface2-foo')
        self.assertEquals(util.__name__, name)
        self.failUnless(name in obj.objectIds())

        util = queryUtility(IDummyInterface)
        self.failUnless(IDummyInterface.providedBy(util))
        self.failUnless(util.verify())
        self.failUnless(util.__parent__ == obj)
        name = 'dummy_utility'
        self.assertEquals(util.__name__, name)
        self.failUnless(name in obj.objectIds())

        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(obj.aq_parent, 'dummy_tool')
        self.assertEqual(tool.meta_type, 'dummy tool')
        self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))

        util = queryUtility(IDummyInterface2, name='dummy tool name2')
        self.failUnless(IDummyInterface2.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(obj.aq_parent, 'dummy_tool2')
        self.assertEqual(tool.meta_type, 'dummy tool2')
        self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))
Exemplo n.º 49
0
    def getCalendars(self):
        """Get a list of calendars to display."""
        providers = subscribers((self.context, self.request), ICalendarProvider)

        coloured_calendars = []
        for provider in providers:
            coloured_calendars += provider.getCalendars()

        calendars = [calendar for (calendar, color1, color2)
                     in coloured_calendars]
        return calendars
Exemplo n.º 50
0
 def get_listing_view_adapters(self):
     """Returns subscriber adapters used to modify the listing behavior,
     sorted from higher to lower priority
     """
     # Allows to override this listing by multiple subscribers without the
     # need of inheritance. We use subscriber adapters here because we need
     # different add-ons to be able to modify columns, etc. without
     # dependencies amongst them.
     adapters = subscribers((self, self.context), IListingViewAdapter)
     return sorted(adapters, key=lambda ad: api.to_float(
         getattr(ad, "priority_order", 1000)))
Exemplo n.º 51
0
 def __call__(self, CachableSource, CachedItemFactory):
     item = CachableSource.first()
     if not item:
         raise ValueError("expected CachableSource to be able to generate at least 1 item.")
     for mapper in subscribers((CachableSource,CachedItemFactory,), ICachedItemMapper):
         logger.debug("testing mapper/cachedItem combination: %s, %s", str(mapper), str(CachedItemFactory))
         if mapper.check(item):
             logger.debug("found valid ICachedItemMapper %s", str(mapper))
             return mapper
         logger.debug("skipping CachedItemMapper %s because item failed mapper validation check", str(mapper))
     raise LookupError("unable to find subscribed ICachedItemMapper for given source and factory: %s, %s", str(CachableSource). str(CachedItemFactory))
Exemplo n.º 52
0
    def validate(self):
        # Instead of calling P.Archetypes.BaseObject.validate() we have to
        # provide a custom validation implementation here because some
        # validators extract the field value from the request. However a JSON
        # API request does not contain any form values in the request.
        # Thus we fake a request that extracts form values from the object on
        # demand.

        obj = self.context
        request = ValidationRequest(self.request, obj)
        errors = {}

        obj.pre_validate(request, errors)

        for pre_validator in subscribers((obj, ), IObjectPreValidation):
            pre_errors = pre_validator(request)
            if pre_errors is not None:
                for field_name, error_message in pre_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        obj.Schema().validate(instance=obj,
                              REQUEST=None,
                              errors=errors,
                              data=True,
                              metadata=True)

        obj.post_validate(request, errors)

        for post_validator in subscribers((obj, ), IObjectPostValidation):
            post_errors = post_validator(request)
            if post_errors is not None:
                for field_name, error_message in post_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        return errors
Exemplo n.º 53
0
    def __get__(self, form, type=None):
        if form is None:
            return Fields()

        cache = form.__dict__.get(self.key, None)
        if cache is None and IBrowserView.providedBy(form):
            providers = component.subscribers(
                (form.context, form), self.interface)
            providers = sort_components(providers)
            cache = Fields(*(p.fields for p in providers))
            form.__dict__[self.key] = cache
        return cache
Exemplo n.º 54
0
def notifyFieldEvent(event):
    field = event.field
    if IFieldRenderEvent.providedBy(event):
        event.value = getMultiAdapter((field, event), IFieldValue)
        if event.kwargs.get('raw', False) or getattr(event, 'raw', False):
            # bail out
            return

    handle(event.field, event.instance, event)

    if IFieldStorageEvent.providedBy(event):
        for ignore in subscribers((field, event), IFieldValueSetter):
            pass
Exemplo n.º 55
0
    def __api_processor(self, valid_dispatch, valid_response, isubscriber):

        """

        Will loop through a valid response objects and will compare it to a registered
        protocol subscribers

        :param valid_dispatch:
        :param valid_response:
        :param isubscriber:

        :return: The chosen API or False
        """
        for sub in subscribers([valid_response], isubscriber):

            self.__logger.debug('Matched request subscribers: {}'.format(sub.__class__.__name__))

            try:

                verifyObject(isubscriber, sub)

            except DoesNotImplement as e:

                self.__logger.warning('Incorrect implementation: {}'.format(e))

            else:

                comp = sub.compare()

                if comp is not False and IJSONResource.providedBy(comp):

                    self.__logger.debug('Signature compare to {}'.format(comp.__class__.__name__))

                    # trying to resolve API that will deal with these request

                    if len(comp.to_dict().keys()) > 1:
                        # process request without root element
                        return NonRootAPI(comp).check()

                    else:
                        # root element
                        return RootAPI(comp).check()

        # if there are no one subsciber from IJSONResource

        self.__logger.warning('The request {} from type {} was not recognized as a structure or an API'.format(
            valid_response.response,
            valid_dispatch.message_type
        ))

        return False
Exemplo n.º 56
0
    def validate(self):
        # Instead of calling P.Archetypes.BaseObject.validate() we have to
        # provide a custom validation implementation here because some
        # validators extract the field value from the request. However a JSON
        # API request does not contain any form values in the request.
        # Thus we fake a request that extracts form values from the object on
        # demand.

        obj = self.context
        request = ValidationRequest(self.request, obj)
        errors = {}

        obj.pre_validate(request, errors)

        for pre_validator in subscribers((obj,), IObjectPreValidation):
            pre_errors = pre_validator(request)
            if pre_errors is not None:
                for field_name, error_message in pre_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        obj.Schema().validate(instance=obj, REQUEST=None,
                              errors=errors, data=True, metadata=True)

        obj.post_validate(request, errors)

        for post_validator in subscribers((obj,), IObjectPostValidation):
            post_errors = post_validator(request)
            if post_errors is not None:
                for field_name, error_message in post_errors.items():
                    if field_name in errors:
                        errors[field_name] += " %s" % error_message
                    else:
                        errors[field_name] = error_message

        return errors
Exemplo n.º 57
0
 def _updateSymptoms(self):
     self._symptoms = [
         symptom
         for symptom in subscribers((self.context,), ISymptom)
         if symptom.isActive
     ]
     for symptom in self._symptoms:
         self._byTitle[symptom.title] = symptom
         self._byName[symptom.name] = symptom
     self._ignored_symptoms = [
         symptom 
         for symptom in self._symptoms
         if symptom.isIgnored
     ]