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

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'')

 def __init__(self, context):
     self.context = context
     self.portal = getToolByName(self.context, 'portal_url').getPortalObject()
     storage = IAnnotations(self.portal)
     if not storage.has_key(STORAGE_KEY):
         storage[STORAGE_KEY] = PersistentDict()
     self.storage = storage[STORAGE_KEY]

 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

def registerPersistentConfig(site, type_):
    """ Try to get persistent pipeline configuration of given type (export or import)
        and register it for use with transmogrifier.
    """
    global CONFIGFILE
    anno = IAnnotations(site)
    key = '%s.%s' % (ANNOKEY, type_)
    config = anno.has_key(key) and anno[key] or None

    # unregister old config
    name = 'persitent-%s' % type_
    if name in configuration_registry._config_ids:
        configuration_registry._config_ids.remove(name)
        del configuration_registry._config_info[name]

    # register new
    if config is not None:
        title = description = u'Persistent %s pipeline'
        tf = tempfile.NamedTemporaryFile('w+t', suffix='.cfg')
        tf.write(config)
        tf.seek(0)
        CONFIGFILE = tf
        configuration_registry.registerConfiguration(name, title, description, tf.name)
        return name
    else:
        return None

 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)

def get_users_statistics_reports(site):
    """ Get existing reports saved in annotations
    """
    annotations = IAnnotations(site)
    reports = annotations.get(USERS_STATISTICS_KEY, None)

    return reports

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

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'))

 def __call__(self):
     form = self.request.form
     context = aq_inner(self.context)
     annotations = IAnnotations(context)['collective.pfg.payment']
     if form.get("form.button.UpdateNumber", None) is not None:
         sdm = getToolByName(context, 'session_data_manager')
         session = sdm.getSessionData(create=False)
         if session is not None:
             if session.get('collective.pfg.payment.number', None) is not None:
                 del session['collective.pfg.payment.number']
         re = getUtility(IRegularExpression)
         numbering_type = form.get('numbering_type')
         if numbering_type == 'Incremental':
             annotations.numbering_type = 'Incremental'
             next_incremental_number = form.get('next_incremental_number', None)
             if re.integer(next_incremental_number):
                 annotations.next_incremental_number = int(next_incremental_number)
             else:
                 message = _(u"Please input integer number for the incremental number.")
                 IStatusMessage(self.request).addStatusMessage(message, type='warn')
         elif numbering_type == 'Random':
             annotations.numbering_type = 'Random'
             random_number_digits = form.get('random_number_digits', None)
             if re.integer(random_number_digits):
                 annotations.random_number_digits = int(random_number_digits)
             else:
                 message = _(u"Please input integer number for the randome digits.")
                 IStatusMessage(self.request).addStatusMessage(message, type='warn')
     return self.template()

 def after_resolve_jobs_pending(self):
     """This flag tracks whether these jobs have already been executed for
     a resolved dossier, or are still pending (because they have been
     deferred to a nightly job).
     """
     ann = IAnnotations(self.context)
     return ann.get(AFTER_RESOLVE_JOBS_PENDING_KEY, False)

 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

 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()

def update_opengraphable_objects(context, new_ct):
    g_marker = queryUtility(IOpengraphMarkerUtility)
    if not g_marker:
        return
    options = IAnnotations(context)

    ct = getToolByName(context, 'portal_catalog')

    olds_pt = options.get('old_content_types', [])
    if new_ct == olds_pt:
        return
    adds = []
    for new in new_ct:
        if new in olds_pt:
            olds_pt.remove(new)
        else:
            adds.append(new)

    nb_items, bad_items = g_marker.update(context, adds, olds_pt)
    updated = u'%d %s' % (nb_items, _(u'objects updated.'))
    if not bad_items:
        message = updated
    else:
        message = u'%s, %d %s: %s' % (updated,
                                      len(bad_items),
                                      _(u'update(s) on object(s) failed'),
                                      ','.join(bad_items), )
    pu = getToolByName(context, 'plone_utils')
    pu.addPortalMessage(message)

 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)

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'))

 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')

 def queue(self):
     queue = getattr(self, "_queue", None)
     if queue is None:
         annotations = IAnnotations(self.context)
         if not annotations.has_key(self.key):
             annotations[self.key] = IOBTree()
         self._queue = annotations[self.key]
     return self._queue

 def _migrate_related_items_annotations(self):
     query = {'portal_type': 'opengever.document.document',
              'object_provides': IHasRelations.__identifier__}
     for obj in self.objects(query, 'Migrate relatedItems annotations'):
         ann = IAnnotations(obj)
         if OLD_KEY in ann:
             ann[NEW_KEY] = ann[OLD_KEY]
             ann.pop(OLD_KEY)

    def test_setData_stores_data(self):
        annotations = IAnnotations(self.layer['portal'])
        self.assertIsNone(annotations.get(ANNOTATION_KEY))

        component = getAdapter(self.layer['portal'], IDataCollector,
                               name='ftw.servicenavigation')
        component.setData(EXAMPLE_DATA)
        self.assertEqual(EXAMPLE_DATA, annotations[ANNOTATION_KEY])