Dato che ora sai tutto degli adattatori Z3, potresti voler usare le nostre interfacce per definire nuovi filtri e visitare la tua gerarchia.

Per cominciare, dai un bello sguardo all'interessante interfaccia IFilterFolder che trovi in Products.ATContentTypes.interface.folder.IFilterFolder. Questa interfaccia dice quello che devi definire per creare un filtro corretto:

    class IFilterFolder(Interface):

        def listObjects():
            """
              restituisce la lista degli oggetti filtrati senza controllare la sicurezza
            """

        def listPermittedObjects():
            """
              restituisce la lista degli oggetti filtrati e controllando la sicurezza
            """

        def filter(context):
            """
              filtra gli oggetti nel contesto da visitare con TreeWalker.
              Questo metodo è privato e non dovrebbe essere richiamato dall'esterno.
              Usa listObjects() piuttosto
            """

Non aggiungerò commenti su questa interfaccia, poiché si descrive da sola.

Ora diamo uno sguardo a Products.ATContentTypes.adapters.folder; lì ci trovi la classe Filter:

        class Filter(object):
            def __init__(self, context):
                """
                  il context dovrebbe essere un oggetto folderish
                """
                self.context = context

            def listObjects(self):

                """
                    restituisce la lista degli oggetti filtrati senza controlli di sicurezza
                """
                return self.filter()

            def listPermittedObjects(self):
                """
                   restituisce la lista degli oggetti filtrati tenendo conto della sicurezza
                """
                return LazyFilter(self.filter(), skip='')

            def filter(self):
                """
                    filtra gli oggetti nel context che viene visitato da TreeWalker.
                """
                raise NotImplementedError, 'This method should be overriden in a subclass'

            def __call__(self):
                return self.listPermittedObjects()

Come puoi vedere, questa classe implementa quasi IFilterFolder. Per quasi intendo che c'è solo un metodo non chiaramente implementato, il metodo filter. Perciò l'unica cosa di cui hai bisogno per creare un nuovo filtro è quella di implementare questo metodo ed ereditare dalla classe Filter. Facciamolo!

Diciamo di voler ottenere tutti i documenti nella cartella che si trovano nello stato di workflow "published":

        >>> from Products.ATContentTypes.adapters.folder import Filter
        >>> from Products.ATContentTypes.interface.folder import IFilterFolder
        >>> from Products.CMFCore.utils import getToolByName
        >>> class FilterPublishedDocument(Filter):
        ...     """
        ...         prende solo i documenti pubblicati nella cartella
        ...     """
        ...     implements(IFilterFolder)
        ...
        ...     def filter(self):
        ...         workflow = getToolByName(self.context, 'portal_workflow')
        ...         publishedDocuments = []
        ...         for document in self.context.objectValues('Document'):
        ...             if(workflow.getInfoFor(document,'review_state') == 'published'):
        ...                 publishedDocument.append(document)
        ...
        ...         return publishedDocuments

Questo è tutto per il filtraggio. Se vuoi usarlo nel treeWalker dovresti collegare questo filtro all'oggetto folderish che vuoi visitare (dovrebbe essere ATFolder), o dai semplicemente la classe FilterPublishedDocument come parametro all'inizializzazione del TreeWalker.

Per usare FilterPublishedDocument per ATFolder lo zcml dovrebbe essere come questo:

        <adapter
            for="Products.ATContentTypes.interface.IATFolder"
            factory="Products.ATContentTypes.adapters.folder.FilterPublishedDocument"
            provides="Products.ATContentTypes.interface.IFilterFolder"
            />

Da notare che potremmo aver usato il catalogo nel filtraggio per filtrare gli oggetti in uno specifico stato (questo renderebbe tutto un po' più veloce  ma meno semplice).