Python IAnnotations.get方法代码示例

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def __call__(self, *args, **kw):
     context = self.context
     request = self.request
     request.set('disable_border', 1)
     # following two only on Plone 4+
     request.set('disable_plone.leftcolumn', 1)
     request.set('disable_plone.rightcolumn', 1)
     self.error = False
     
     token = request.form.get('token')
     path = request.form.get('path')
     comment = request.form.get('comment', None)
     
     doc = context.unrestrictedTraverse(path)
     conf = IAnnotations(doc).get('share-tokens')
     
     if conf.get('reject') and conf.get('reject')==token and not comment.strip():
         # comment when rejecting is required
         context.plone_utils.addPortalMessage(_(u'When rejecting, a motivation is required'),
                                              type='error')
         request.response.redirect(request.form.get('came_from') or context.absolute_url())
         return
     
     try:
         self.result = ConsumePowerTokenView.__call__(self, comment=comment, **kw)[0]
     except PowerTokenSecurityError:
         self.result = None
         self.error = True
     return self.index()

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
class BasicProfile(object):

    implements(IBasicProfile)
    adapts(IPrincipal)

    def __init__(self, principal):
        self.annotations = IAnnotations(principal)
        self.principal = principal

    @setproperty
    def name(self, v):
        self.annotations['name'] = v

        # for principalfolder search
        ip = internal_principal(self.principal.id)
        ip.title = v

    @getproperty
    def name(self):
        return self.annotations.get('name', self.principal.title)

    @setproperty
    def email(self, v):
        self.annotations['email'] = v

    @getproperty
    def email(self):
        return self.annotations.get('email', u'')

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def _initialize(self, create=False):
     if self.storage is not None:
         return
     storage = IAnnotations(self.context)
     if storage.get(ANNOTATIONS_KEY, None) is None:
         storage[ANNOTATIONS_KEY] = dict.PersistentDict()
         storage[ANNOTATIONS_KEY]['notifications'] = IOBTree()
         storage[ANNOTATIONS_KEY]['user'] = OOBTree()
         storage[ANNOTATIONS_KEY]['intid'] = 1
     self.storage = storage.get(ANNOTATIONS_KEY, None)

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
    def __call__(self):
        disable_edit_bar()

        annotations = IAnnotations(self.context)
        self.source_document = uuidToObject(annotations.get(PDF_SAVE_SOURCE_UUID_KEY))
        self.version_id = annotations.get(PDF_SAVE_SOURCE_VERSION_KEY)
        self.destination_document = self.context
        self.destination = self.context.get_parent_dossier()
        self.trigger_conversion()
        return self.template()

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
class MegaphoneRenderer(BrowserView):
    """
    This is a view of a Megaphone action which renders the letter based on the
    request form variables and the template stored in an annotation on the
    form folder.
    """
    
    def __init__(self, context, request):
        self.context = context
        self.request = request
        self.data = IAnnotations(context).get(ANNOTATION_KEY, PersistentDict())

    def render_letter(self, request=None):
        if request is None:
            request = self.request
        transformer = getToolByName(self.context, 'portal_transforms')
        template = self.data.get('template', '${sender_body}')
        return transformer(
            'web_intelligent_plain_text_to_html',
            _dreplace(template, self.context, request)
            )

    def render_plaintext_letter(self):
        template = self.data.get('template', '${sender_body}')
        return _dreplace(template, self.context, self.request).encode('utf8')

    def render_all_letters(self):
        letters = []
        for request in recipient_multiplexer(self.context, self.request):
            letters.append(self.render_letter(request=request))
        return letters

    def render_thankyou(self):
        transformer = getToolByName(self.context, 'portal_transforms')
        template = self.data.get('thankyou_template', '')
        return transformer(
            'web_intelligent_plain_text_to_html',
            _dreplace(template, self.context, self.request)
            )
    
    def render_recipient_source_snippets(self):
        out = []
        for _, source in getAdapters((self.context, self.request), IRecipientSource):
            out.append(source.render_form())
        return ''.join(out)
    
    def render_recipients_list(self):
        recipients = []
        for _, source in getAdapters((self.context, self.request), IRecipientSource):
            for recipient in source.lookup():
                recipients.append(recipient_label(recipient))
        return recipients

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def get_slid(self):
     """slideshare slideshowid or redirect to upload"""
     annotations = IAnnotations(self.context)
     sl_id = annotations.get(KEY, None)
     if sl_id:
         return sl_id
     else:
         if IATFile.providedBy(self.context):
             if self.context.getContentType() in SLIDES_MIMETYPES:
                 self.request.response.redirect(
                     self.context.absolute_url() +
                             '/@@slideshare_post.html')
             else:
                 msg = _(u"This file does not seem to be a presentation")
                 IStatusMessage(self.request).addStatusMessage(msg,
                         type='error')
         elif IATLink.providedBy(self.context):
             urlob = urlparse(self.context.getRemoteUrl())
             if urlob.hostname == 'www.slideshare.net':
                  self.request.response.redirect(
                     self.context.absolute_url() +
                             '/@@slideshare_getid.html')
             else:
                 msg = _(u"This is not a valid slideshare URL")
                 IStatusMessage(self.request).addStatusMessage(msg,
                         type='error')

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def __init__(self, context):
     self.ideal_wrapper = getUtility(IMollieIdeal)
     annotations = IAnnotations(context)
     self._metadata = annotations.get(IDEAL_PAYMENT_ANNOTATION_KEY, None)
     if self._metadata is None:
         self._metadata = PersistentMapping()
         annotations[IDEAL_PAYMENT_ANNOTATION_KEY] = self._metadata

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
def disable_behaviors(obj, behaviors, ifaces, reindex=True):
    """ Disable behaviors on an object.

    :param obj: The Dexterity content object to disable behaviors on.
    :type obj: object
    :param behaviors: Behaviors to be disabled on the object. This is a list of
                      dotted names of behavior schema interfaces.
    :type behaviors: list or tuple
    :param ifaces: Behavior marker interfaces belonging to the behaviors to be
                   disabled. This is a list of interface classes.
    :type ifaces: class
    :param reindex: Flag whether to reindex object after modification
    :type reindex: bool

    Use it like so:

    >>> from plone.app.event.dx.interfaces import IDXEvent
    >>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
    ...                        [IDXEvent,])
    """
    annotations = IAnnotations(obj)
    instance_behaviors = annotations.get(ANNOTATION_KEY, ())
    instance_behaviors = filter(lambda x: x not in behaviors,
                                instance_behaviors)
    annotations[ANNOTATION_KEY] = instance_behaviors

    for iface in ifaces:
        noLongerProvides(obj, iface)

    if reindex:
        obj.reindexObject(idxs=('object_provides'))

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def _getHandle(self, context):
     """
     Helper method looking up the handle in the context's annotation.
     Returns None if not existing.
     """
     annotations = IAnnotations(context)
     return annotations.get(KEY, None)

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
class NotificationConfiglet(BrowserView):
    
    template = ViewPageTemplateFile('configlet.pt')
    
    def __call__(self, delete=None):
        self.storage = IAnnotations(self.context)
        if delete and self.storage.has_key(STORAGE_KEY) and self.storage[STORAGE_KEY].has_key(delete):
            del self.storage[STORAGE_KEY][delete]
            statusmessages = IStatusMessage(self.request)
            statusmessages.addStatusMessage(_('message_deleted', default='Notification template deleted'), type='info')
        
        return self.template()
    
    @memoize
    def templates(self):
        if not self.storage.has_key(STORAGE_KEY):
            return []
        templates_raw = self.storage.get(STORAGE_KEY)
        vocabulary = availableWorkflows(self.context)
        templates = []
        for name, template in templates_raw.items():
            template = {'name': name,
                        'template': template}
            try:
                term = vocabulary.getTermByToken(name)
                template.update(dict(title=(term.title or term.token)))
            except:
                pass
            templates.append(template)
        return templates

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def handle(self):
     """
     Looks up the handle in the context's annotation.
     Returns None if not found.
     """
     annotations = IAnnotations(self.context)
     return annotations.get(KEY, None)

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def __init__(self, context):
     self.context = self.__parent__  = context # see PvWh book site 269
     annotations = IAnnotations(context)
     mapping = annotations.get(EntryNavAnnotations_KEY)
     if mapping is None:
         mapping = annotations[EntryNavAnnotations_KEY] = PersistentDict({'name': '', 'order': 0})
     self.mapping = mapping

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
def disable_behaviors(obj, behaviors, ifaces):
    """ Disable behaviors on an object.

    :param obj: The Dexterity content object to disable behaviors on.
    :type obj: object
    :param behaviors: Behaviors to be disabled on the object. This is a list of
                      dotted names of behavior schema interfaces.
    :type behaviors: list
    :param ifaces: Behavior marker interfaces belonging to the behaviors to be
                   disabled. This is a list of interface classes.
    :type ifaces: class

    Use it like so:
    >>> from plone.app.event.dx.interfaces import IDXEvent
    >>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
    ...                        [IDXEvent,])

    """
    annotations = IAnnotations(obj)
    instance_behaviors = list(annotations.get(KEY, []))
    instance_behaviors = filter(lambda x: x not in behaviors,
                                instance_behaviors)
    annotations[KEY] = instance_behaviors

    for iface in ifaces:
        noLongerProvides(obj, iface)

    # TODO UNTESTED:
    obj.reindexObject(idxs=('object_provides'))

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
 def _default_stylebook(self):
     if not getattr(self, '_default', None):
         if not [o.getId() for o in self.stylebooks()]:
             return None
         anno = IAnnotations(self.context).get(ANNO_KEY, {})
         self._default = anno.get('default_stylebook', None)
     return self._default

# 需要导入模块: from zope.annotation import IAnnotations [as 别名]
# 或者: from zope.annotation.IAnnotations import get [as 别名]
def get_users_statistics_reports(site):
    """ Get existing reports saved in annotations
    """
    annotations = IAnnotations(site)
    reports = annotations.get(USERS_STATISTICS_KEY, None)

    return reports