Python referenceable.IReferenceable类代码示例

    def afterRetrieveModifier(self, obj, repo_clone, preserve=()):
        # check if the modifier is called with a valid working copy
        if obj is None:
            return [], [], {}

        if (
            (
                HAVE_Z3_IFACE
                and IReferenceable.providedBy(obj)
                or not HAVE_Z3_IFACE
                and IReferenceable.isImplementedBy(obj)
            )
            and hasattr(aq_base(obj), REFERENCE_ANNOTATION)
            and hasattr(aq_base(repo_clone), REFERENCE_ANNOTATION)
        ):
            # Remove AT references that no longer exists in the retrived version
            orig_refs_container = getattr(aq_base(obj), REFERENCE_ANNOTATION)
            repo_clone_refs_container = getattr(aq_base(repo_clone), REFERENCE_ANNOTATION)
            ref_objs = orig_refs_container.objectValues()
            repo_clone_ref_ids = repo_clone_refs_container.objectIds()

            reference_catalog = getToolByName(obj, "reference_catalog")
            if reference_catalog:
                for ref in ref_objs:
                    if ref.getId() not in repo_clone_ref_ids:
                        reference_catalog.deleteReference(ref.sourceUID, ref.targetUID, ref.relationship)

        return [], [], {}

    def afterRetrieveModifier(self, obj, repo_clone, preserve=()):
        # check if the modifier is called with a valid working copy
        if obj is None:
            return [], [], {}

        if (HAVE_Z3_IFACE and IReferenceable.providedBy(obj)
            or not HAVE_Z3_IFACE and IReferenceable.isImplementedBy(obj)) \
        and hasattr(aq_base(obj), REFERENCE_ANNOTATION):
            #Preserve AT references
            orig_refs_container = getattr(aq_base(obj), REFERENCE_ANNOTATION)
            setattr(repo_clone, REFERENCE_ANNOTATION, orig_refs_container)

        return [], [], {}

 def test_implements(self):
     if self.dummy is not None:
         self.failIf(IReferenceable.providedBy(self.dummy))
         self.failIf(IExtensibleMetadata.providedBy(self.dummy))
         self.failIf(self.dummy.isReferenceable)
         self.failUnless(IBaseContent.providedBy(self.dummy))
         self.failUnless(IATTopicCriterion.providedBy(self.dummy))
         self.failUnless(verifyObject(IBaseContent, self.dummy))
         self.failUnless(verifyObject(IATTopicCriterion, self.dummy))

    def _get_references_for(self, context):
        try:
            referenceable = IReferenceable(context)
        except TypeError:
            # could not adapt
            # this means we have a dexterity object without
            # plone.app.referenceablebehavior activated.
            objs = []
        else:
            objs = referenceable.getReferences()

        if HAS_ZC_RELATION:
            relation_catalog = getUtility(ICatalog)
            obj_intid = getUtility(IIntIds).getId(context)
            relations = tuple(relation_catalog.findRelations({'from_id': obj_intid}))
            objs += map(attrgetter('to_object'), relations)

        return list(set(objs))

 def test_implements(self):
     if self.dummy is not None:
         self.assertFalse(IReferenceable.providedBy(self.dummy))
         self.assertFalse(IExtensibleMetadata.providedBy(self.dummy))
         self.assertFalse(self.dummy.isReferenceable)
         self.assertTrue(IBaseContent.providedBy(self.dummy))
         self.assertTrue(IATTopicCriterion.providedBy(self.dummy))
         self.assertTrue(verifyObject(IBaseContent, self.dummy))
         self.assertTrue(verifyObject(IATTopicCriterion, self.dummy))

    def _fixupATReferences(self, obj):
        """Reindex AT reference data, and delete reference
        implementations when the target
        doesn't exist anymore.

        Deletion of references is done at the end of the
        recursiveRetrieve operation to avoid deleting refs to targets
        that will be retrieved later in the recursiveRetrive. It
        doesn't call refcatalog.deleteReference as that method uses
        brains to retrieve reference implementations. If the
        target doesn't exist, brains for references pointing to it
        do not exist either.

        This manually calls reference.delHook to let it finalize
        correctly but traps ReferenceException eventually emitted in
        the process and forces the deletion, because leaving the
        reference impl. there will leave refcatalog in an
        incosistent state.
        """

        if (
            HAVE_Z3_IFACE and
            IReferenceable.providedBy(obj) or
            not HAVE_Z3_IFACE and
            IReferenceable.isImplementedBy(obj)
        ) and hasattr(obj, REFERENCES_CONTAINER_NAME):
            # Delete refs if their target doesn't exists anymore
            ref_folder = getattr(obj, REFERENCES_CONTAINER_NAME)
            uid_catalog = getToolByName(self, "uid_catalog")
            ref_catalog = getToolByName(self, "reference_catalog")
            ref_objs = ref_folder.objectValues()
            for ref in ref_objs:
                if not uid_catalog(UID=ref.targetUID):
                    try:
                        # at's _deleteReference passes the catalog
                        # itself, the source and target obj... i'm
                        # going to emulate it as much as i can
                        ref.delHook(ref_catalog, obj, None)
                    except ReferenceException:
                        pass
                    ref_folder.manage_delObjects(ref.getId())
            # then reindex references
            container = aq_parent(aq_inner(obj))
            obj._updateCatalog(container)

 def _listTypeInfo(self):
     """ List the portal types which are available.
     """
     pt = getToolByName(self, "portal_types", None)
     at = getToolByName(self, "archetype_tool", None)
     if (pt is None) or (at is None):
         return ()
     else:
         meta_types = [
             ty["meta_type"]
             for ty in at.listRegisteredTypes()
             if IReferenceable.isImplementedByInstancesOf(ty["klass"])
         ]
         tis = [t for t in pt.objectValues() if t.content_meta_type in meta_types]
         tis.sort(lambda a, b: cmp(a.Title(), b.Title()))
         return tis

def is_referenceable(obj):
    """Find out if this object (AT or DX) is referenceable.

    Return True if a obj can be referenced using the reference_catalog used by
    Archetypes-Relations and Linkintegrity.

    Relations using the relation_catalog (zc.relation.interfaces.ICatalog) are
    not covered by this test!
    """
    is_referenceable = False
    if IReferenceable.providedBy(obj) or \
            safe_hasattr(aq_base(obj), 'isReferenceable'):
        is_referenceable = True
    else:
        try:
            # This most likely the case when plone.app.referenceablebehavior
            # is enabled.
            obj = IReferenceable(obj)
            is_referenceable = True
        except TypeError:
            is_referenceable = False
    return is_referenceable

 def _catalogReferencesFor(self, obj, path):
     if IReferenceable.providedBy(obj):
         obj._catalogRefs(self)

 def isReferenceable(self, object):
     return (IReferenceable.providedBy(object) or
             shasattr(object, 'isReferenceable'))

 def _catalogReferencesFor(self,obj,path):
     if IReferenceable.isImplementedBy(obj):
         obj._catalogRefs(self)

 def isReferenceable(self, object):
     return (IReferenceable.isImplementedBy(object) or
             shasattr(object, 'isReferenceable'))

def modify_fti(fti, klass, pkg_name):
    fti[0]['id'] = klass.__name__
    fti[0]['meta_type'] = klass.meta_type
    fti[0]['description'] = klass.__doc__
    fti[0]['factory'] = 'add%s' % klass.__name__
    fti[0]['product'] = pkg_name

    if hasattr(klass, 'content_icon'):
        fti[0]['content_icon'] = klass.content_icon

    if hasattr(klass, 'global_allow'):
        fti[0]['global_allow'] = klass.global_allow

    if hasattr(klass, 'allow_discussion'):
        fti[0]['allow_discussion'] = klass.allow_discussion

    if hasattr(klass, 'allowed_content_types'):
        allowed = klass.allowed_content_types
        fti[0]['allowed_content_types'] = allowed
        fti[0]['filter_content_types'] = allowed and True or False

    if hasattr(klass, 'filter_content_types'):
        fti[0]['filter_content_types'] = klass.filter_content_types

    if hasattr(klass, 'immediate_view'):
        fti[0]['immediate_view'] = klass.immediate_view

    if not IReferenceable.isImplementedByInstancesOf(klass):
        refs = findDict(fti[0]['actions'], 'id', 'references')
        refs['visible'] = False

    if not IExtensibleMetadata.isImplementedByInstancesOf(klass):
        refs = findDict(fti[0]['actions'], 'id', 'metadata')
        refs['visible'] = False

    # Set folder_listing to 'view' if the class implements ITemplateMixin
    if not ITemplateMixin.isImplementedByInstancesOf(klass):
        actions = []
        for action in fti[0]['actions']:
            if action['id'] != 'folderlisting':
                actions.append(action)
            else:
                action['action'] = 'string:${folder_url}/view'
                actions.append(action)
        fti[0]['actions'] = tuple(actions)

    # Remove folderlisting action from non folderish content types
    if not getattr(klass,'isPrincipiaFolderish', None):
        actions = []
        for action in fti[0]['actions']:
            if action['id'] != 'folderlisting':
                actions.append(action)
        fti[0]['actions'] = tuple(actions)
        
    # CMF 1.5 method aliases
    if getattr(klass, 'aliases', None):
        aliases = klass.aliases
        if not isinstance(aliases, dict):
            raise TypeError, "Invalid type for method aliases in class %s" % klass
        for required in ('(Default)', 'view',):
            if required not in aliases:
                raise ValueError, "Alias %s is required but not provied by %s" % (
                                  required, klass)
        fti[0]['aliases'] = aliases 
        
    # Dynamic View FTI support
    if getattr(klass, 'default_view', False):
        default_view = klass.default_view
        if not isinstance(default_view, basestring):
            raise TypeError, "Invalid type for default view in class %s" % klass
        fti[0]['default_view'] = default_view
        fti[0]['view_methods'] = (default_view, )
        
        if getattr(klass, 'suppl_views', False):
            suppl_views = klass.suppl_views
            if not isinstance(suppl_views, (list, tuple)):
                raise TypeError, "Invalid type for suppl views in class %s" % klass
            if not default_view in suppl_views:
                suppl_views = suppl_views + (default_view, )
            fti[0]['view_methods'] = suppl_views
    if getattr(klass, '_at_fti_meta_type', False):
        fti[0]['fti_meta_type'] = klass._at_fti_meta_type
    else:
        if fti[0].get('fti_meta_type', False):
            klass._at_fti_meta_type = fti[0]['fti_meta_type']
        else:
            fti[0]['fti_meta_type'] = FactoryTypeInformation.meta_type

 def test_doesImplementAT(self):
     self.assertTrue(IBaseContent.providedBy(self._ATCT))
     self.assertTrue(IReferenceable.providedBy(self._ATCT))
     self.assertTrue(verifyObject(IBaseContent, self._ATCT))
     self.assertTrue(verifyObject(IReferenceable, self._ATCT))

    def getData(self):
        """ Returns backreferences:
        {
            'uid-obj-a': {
                'the-field': [
                    'uid-of-another-unpublished-object',
                    'my-uid',
                    'uid-obj-b',
                ],
            },
            'uid-obj-b': {
                'ref-field': 'my-uid',
            },
        }
        """

        data = {}

        if hasattr(aq_base(self.context), 'getBackReferenceImpl'):
            referenceable = self.context

        else:
            try:
                referenceable = IReferenceable(self.context)

            except TypeError:
                # could not adapt
                # this means we have a dexterity object without
                # plone.app.referenceablebehavior activated.
                return data

        old_security_manager = getSecurityManager()
        newSecurityManager(self.context.REQUEST, SpecialUsers.system)
        try:
            references = referenceable.getBackReferenceImpl()
        finally:
            setSecurityManager(old_security_manager)

        for ref in references:
            # get source object
            src = ref.getSourceObject()
            if src is None:
                continue

            suid = src.UID()

            if suid not in data.keys():
                data[suid] = {}
            if getattr(ref, 'field', None) is None:
                continue

            if ref.field in data[suid]:
                # we already added this field
                continue
            else:
                # add the field value
                field = src.getField(ref.field)
                if field:
                    data[suid][ref.field] = field.getRaw(src)

        return data