def __iter__(self):
     checkme = aq_base(self.context)
     if IBibliographicItem.providedBy(checkme):
         biblio = queryAdapter(self.context, IBibliographicReference)
         if biblio is not None:
             yield biblio
     # common collection/topic API
     elif hasattr(checkme, 'queryCatalog'):
         for brain in self.context.queryCatalog():
             obj = brain.getObject()
             biblio = queryAdapter(obj, IBibliographicReference)
             if biblio is not None:
                 yield biblio
     # folderish thingies
     elif hasattr(checkme, 'objectValues'):
         for obj in self.context.objectValues():
             if IBibliographicItem.providedBy(obj):
                 try:
                     biblio = queryAdapter(obj, IBibliographicReference)
                 except AttributeError, e:
                     # this can happen if a bibliographic item does
                     # not have one of the required attributes for the 
                     # adapter.  Log the error
                     msg = "Adaptation of {} to IBibliographicReference "
                     msg += "failed due to a missing attribute: {}"
                     logger.warn(msg.format(obj.id, str(e)))
                     continue
                 if biblio is not None:
                     yield biblio

    def graph(self):
        """ Construct graph and mark broken relations if any
        """
        if self._graph is not None:
            return self._graph

        # Valid graph edge
        self._graph = PyGraph()

        value_from = self.context.getField('from').getAccessor(self.context)()
        nfrom = self.tool.get(value_from)
        if nfrom:
            node = queryAdapter(nfrom, INode)
            self._graph.add_node(node())
        else:
            self._bad_content.add(value_from)
            self._bad_relations.add(self.context.Title())

        value_to = self.context.getField('to').getAccessor(self.context)()
        nto = self.tool.get(value_to)
        if nto:
            if value_from != value_to:
                node = queryAdapter(nto, INode)
                self._graph.add_node(node())
        else:
            self._bad_content.add(value_to)
            self._bad_relations.add(self.context.Title())

        edge = queryAdapter(self.context, IEdge)()
        if edge:
            self._graph.add_edge(edge)

        return self._graph

    def test_bug_22_at_plone_org(self):
        """If ICanonicalLink adapter is not found for the context object
           - page rendering should not break, but only canonical link
           should disappear.
        """
        curl = re.compile('<link\srel\s*=\s*"canonical"\s+' \
                         '[^>]*href\s*=\s*\"([^\"]*)\"[^>]*>', re.S|re.M)
        # When adapter registered for the object - canoncal link present on the page
        self.assertNotEqual( queryAdapter(self.my_doc, ICanonicalLink), None)

        res = self.publish(path=self.mydoc_path, basic=self.basic_auth)
        self.assertNotEqual(curl.search(res.getBody()), None)

        # Now remove adapter from the registry -> this should :
        #     - not break page on rendering;
        #     - canonical link will be absent on the page
        gsm = getGlobalSiteManager()
        gsm.unregisterAdapter(DefaultCanonicalLinkAdapter, [ITraversable,],
                              ICanonicalLink)
        self.assertEqual( queryAdapter(self.my_doc, ICanonicalLink), None)

        res = self.publish(path=self.mydoc_path, basic=self.basic_auth)
        self.assertEqual(curl.search(res.getBody()), None)

        # register adapter back in the global site manager
        gsm.registerAdapter(DefaultCanonicalLinkAdapter, [ITraversable,],
                            ICanonicalLink)

    def testI18nResource(self):
        self.assertEqual(component.queryAdapter(request, name='test'), None)

        path1 = os.path.join(tests_path, 'testfiles', 'test.pt')
        path2 = os.path.join(tests_path, 'testfiles', 'test2.pt')

        xmlconfig(StringIO(template % (
            '''
            <browser:i18n-resource name="test" defaultLanguage="fr">
              <browser:translation language="en" file="%s" />
              <browser:translation language="fr" file="%s" />
            </browser:i18n-resource>
            ''' % (path1, path2)
            )))

        v = component.getAdapter(request, name='test')
        self.assertEqual(
            component.queryAdapter(request, name='test').__class__,
            I18nFileResource)
        self.assertEqual(v._testData('en'), open(path1, 'rb').read())
        self.assertEqual(v._testData('fr'), open(path2, 'rb').read())

        # translation must be provided for the default language
        config = StringIO(template % (
            '''
            <browser:i18n-resource name="test" defaultLanguage="fr">
              <browser:translation language="en" file="%s" />
              <browser:translation language="lt" file="%s" />
            </browser:i18n-resource>
            ''' % (path1, path2)
            ))
        self.assertRaises(ConfigurationError, xmlconfig, config)

def _getFieldObjects(self, objTypes=None, includeFSMarkers=False):
    """ return list of enclosed fields """

    # This function currently checks to see if
    # an object is a form field by looking to see
    # if it has an fgField attribute.

    # Make sure we look through fieldsets
    if objTypes is not None:
        objTypes = list(objTypes)[:]
        objTypes.append('FieldsetFolder')

    myObjs = []

    for obj in self.objectValues(objTypes):
        # use shasattr to make sure we're not aquiring
        # fgField by acquisition

        # TODO: If I stick with this scheme for enable overrides,
        # I'm probably going to want to find a way to cache the result
        # in the request. _getFieldObjects potentially gets called
        # several times in a request.

        # first, see if the field enable override is set
        if shasattr(obj, 'fgTEnabled') and obj.getRawFgTEnabled():
            # process the override enabled TALES expression
            # create a context for expression evaluation
            context = getExprContext(self, obj)
            # call the tales expression, passing our custom context
            enabled = obj.getFgTEnabled(expression_context=context)
        else:
            enabled = True

        if enabled:
            if shasattr(obj, 'fgField'):
                myObjs.append(obj)
            if shasattr(obj, 'fieldsetFields'):
                if queryAdapter(obj, interface=ISchemaExtender, name=config.PROJECT_NAME + FieldsetFolderExtender.__name__):
                    # Product is not installed --> nothing to patch
                    obj.setTitle(obj.Title())
                    obj.setDescription(obj.Description())
                myObjs += obj.fieldsetFields(objTypes, includeFSMarkers)

    for field in myObjs:

        if not queryAdapter(field, interface=ISchemaExtender, name=config.PROJECT_NAME + BaseFormFieldExtender.__name__):
            # Product is not installed --> nothing to patch
            continue
        
        field.setTitle(field.Title())
        field.setDescription(field.Description())
        if hasattr(field,'setFgDefault'):
            field.setFgDefault(field.getFgDefault())
        if isinstance(field.fgField, (StringVocabularyField, LinesVocabularyField,)):
            field.fgVocabulary = field.getFgVocabulary()
        if isinstance(field.fgField, LikertField):
            field.setLikertAnswers(field.getLikertAnswers())
            field.setLikertQuestions(field.getLikertQuestions())
    
    return myObjs

    def test_filedetails(self):
        """Testing file details adapters for:
        * generic content type
        * image
        * file
        """
        content = Content()
        adapter = queryAdapter(content, IContentDetails)
        self.assertTrue(isinstance(adapter, BaseContentDetails))

        data = adapter.get_data()
        self.assertEqual([i['label'] for i in data],
            [u'Title', u'Description', u'Type'])

        image = Content()
        alsoProvides(image, IATImage)
        img_adapter = queryAdapter(image, IContentDetails)
        self.assertTrue(isinstance(img_adapter, ImageDetails))

        self.assertEqual([i['label'] for i in img_adapter.get_data()],
            [u'Title', u'Description', u'Type', u'Pixel (w, h)', u'Preview'])

        file_ = Content()
        alsoProvides(file_, IATFile)
        file_adapter = queryAdapter(file_, IContentDetails)
        self.assertTrue(isinstance(file_adapter, FileDetails))

        self.assertEqual([i['label'] for i in file_adapter.get_data()],
            [u'Title', u'Description', u'Type', u'Size', u'Content type'])

    def test_adapters_update_on_LicenceSchedule_modification(self):
        """
        When an other content type is selected on the field 'scheduled_contenttype'
        of a ScheduleConfig, we have to unregister all the IToTaskConfig adapter of
        each TaskConfig of this ScheduleConfig and register them back for the new
        portal_type.
        """
        schedule_config = self.schedule_config
        task_config = self.task_config
        folder = self.portal.config
        document = api.content.create(type='Document', id='doc', container=self.portal)

        # the adapter should be registered for IATFolder
        adapter = getAdapter(folder, IToTaskConfig, task_config.UID())
        msg = "an adapter providing IToTaskConfig should have been registered for IATFolder"
        self.assertTrue(adapter is not None, msg)

        #... but not for IATDocument
        adapter = queryAdapter(document, IToTaskConfig, task_config.UID())
        msg = "not adapter should have been registered for IATDocument yet..."
        self.assertTrue(adapter is None, msg)

        # modify 'scheduled_contenttype' then manually trigger the modification event
        schedule_config.scheduled_contenttype = ('Document', interface_to_tuple(IATDocument))
        notify(ObjectModifiedEvent(schedule_config))

        # old IToTaskConfig adapter should be unregistered for IATFolder
        adapter = queryAdapter(folder, IToTaskConfig, task_config.UID())
        msg = "the adapter should have been unregistered when modifying the ScheduleConfig"
        self.assertTrue(adapter is None, msg)

        # new IToTaskConfig adapter should be registered for IATDocument
        adapter = queryAdapter(document, IToTaskConfig, task_config.UID())
        msg = "an adapter providing IToTaskConfig should have been registered for IATDocument"
        self.assertTrue(adapter is not None, msg)

 def install_profile_upgrades(self, *profileids):
     gatherer = queryAdapter(self.portal_setup, IUpgradeInformationGatherer)
     upgrade_info = [(profile['id'], map(itemgetter('id'), profile['upgrades']))
                     for profile in gatherer.get_upgrades()
                     if profile['id'] in profileids]
     executioner = queryAdapter(self.portal_setup, IExecutioner)
     executioner.install(upgrade_info)

def add_to_repo(obj, event):
    """
    Add a newly created object to the version repository.

    Intended use is as an IObjectAddedEvent subscriber.
    """
    if find_interface(obj, IIntranets):
        # Exclude /offices from repo
        return

    repo = find_repo(obj)
    if repo is None:
        return

    if not repo.history(obj.docid, True):
        # It is not in the repo, so add it
        adapter = queryAdapter(obj, IObjectVersion)
        if adapter is not None:
            if adapter.comment is None:
                adapter.comment = 'Content created.'
            repo.archive(adapter)

    container = event.parent
    adapter = queryAdapter(container, IContainerVersion)
    if adapter is not None:
        request = get_current_request()
        user = authenticated_userid(request)
        repo.archive_container(adapter, user)

    # Recurse into children if adding a subtree
    if IFolder.providedBy(obj):
        for name, child in obj.items():
            fake_event = FakeEvent()
            fake_event.parent = obj
            add_to_repo(child, fake_event)

def _at_back_references(source_object, relationship, translation=None):

    lang = queryAdapter(source_object, ILanguage).get_language()
    if translation:
        lang = queryAdapter(translation, ILanguage).get_language()

    refs = IReferenceable(source_object).getBRefs(relationship=relationship)
    gsm = getSecurityManager()
    result = []
    for obj in refs:
        if ITranslatable.providedBy(obj):
            trans_manager = ITranslationManager(aq_inner(obj))
            try: 
                trans_obj = trans_manager.get_translation(lang)
            except Unauthorized:
                continue

            if trans_obj:
                result.append(trans_obj)
                continue

        if gsm.checkPermission('zope2.View', obj):
            result.append(obj)

    return result

    def json(self, **kwargs):
        """ Implement this method in order to provide a valid exhibit JSON
        """
        res = {'items': [], 'properties': {}}

        # Get data
        adapter = queryAdapter(self.context, IVisualizationData)
        if not (adapter or adapter.data):
            return simplejson.dumps(res)

        # Update JSON with existing annotations properties
        accessor = queryAdapter(self.context, IVisualizationConfig)
        my_json = {'items': [], 'properties': {}}

        my_json = getattr(accessor, 'json', {})
        column_types = kwargs.get('column_types',
                                  None) or self.column_types(my_json)
        annotations = kwargs.get('annotations',
                                 None) or self.annotations(my_json)

        # Convert to JSON
        datafile = StringIO(adapter.data)
        converter = queryUtility(ITable2JsonConverter)
        try:
            _cols, res = converter(datafile,
                                   column_types=column_types,
                                   annotations=annotations)
        except Exception, err:
            logger.debug(err)
            return simplejson.dumps(res)

    def test_indexes(self):
        """Test Indexer indexes.
        """
        with Transaction():
            factory = self.root.manage_addProduct['silva.app.document']
            factory.manage_addDocument('document', 'Test Document')
            version = self.root.document.get_editable()
            version.body.save(version, TestRequest(), """
    <p>
      <h1>Test Document</h1>
      <a class="anchor" name="first" title="First anchor">First anchor</a>
      Some text.
      <a class="anchor" name="second" title="Second anchor">First anchor</a>
    </p>
    """)

        # There are no entries by default, and not published.
        indexes = queryAdapter(self.root.document, IIndexEntries)
        self.assertTrue(verifyObject(IIndexEntries, indexes))
        self.assertEqual(indexes.get_title(), '')
        self.assertEqual(indexes.get_entries(), [])

        # Published, we see the title and the entries
        IPublicationWorkflow(self.root.document).publish()
        indexes = queryAdapter(self.root.document, IIndexEntries)
        self.assertTrue(verifyObject(IIndexEntries, indexes))
        self.assertEqual(indexes.get_title(), 'Test Document')
        self.assertEqual(indexes.get_entries(), [('first', 'First anchor'),
                                                 ('second', 'Second anchor')])

        def _gotSession(sess):
            log.msg(
                'bit.bot.http.socket: BotSocketProtocol.dataReceived._gotSession',
                sess)

            if sess:
                getUtility(ISockets).add('bot', sessionid, token, self)
            request = queryAdapter(self, ISocketRequest, name=data['request'])
            
            if data['request'] == 'message':
                message = data['message']
                if message.startswith('>'):
                    request = getAdapter(self, ISocketRequest, name="command")
                    message = message[1:]
                    data['command'] = message.strip().split(' ')[0]
                    data['args'] = ' '.join(message.strip().split(' ')[1:])
                elif message.startswith('~'):
                    request = getAdapter(
                        self, ISocketRequest, name="subscribe")
                    data['subscribe'] = message[1:]
                else:
                    request = getAdapter(
                        self, ISocketRequest, name="message")
            else:
                request = queryAdapter(
                    self, ISocketRequest, name=data['request'])

            if request:                
                request.load(sessionid, sess, data)

            else:
                print 'NO REQUEST ADAPTER FOR: %s' % data['request']

    def json(self, column_types=None):
        """ Implement this method in order to provide a valid exhibit JSON
        """
        res = {'items': [], 'properties': {}}

        # Get data
        adapter = queryAdapter(self.context, IVisualizationData)
        if not (adapter or adapter.data):
            return simplejson.dumps(res)

        # Update JSON with existing annotations properties
        accessor = queryAdapter(self.context, IVisualizationConfig)
        my_json = {'items': [], 'properties': {}}
        if accessor:
            my_json = accessor.json
            if not column_types:
                column_types = dict(
                    (key, value.get('columnType',
                                    value.get('valueType', 'text'))
                     if isinstance(value, dict) else value)
                    for key, value in my_json.get('properties', {}).items()
                )

        # Convert to JSON
        datafile = StringIO(adapter.data)
        converter = queryUtility(ITable2JsonConverter)
        try:
            _cols, res = converter(datafile, column_types)
        except Exception, err:
            logger.debug(err)
            return simplejson.dumps(res)

def init_repo(repo, context):
    if context.__name__ == 'TEMP':
        return

    if IFolder.providedBy(context):
        for child in context.values():
            init_repo(repo, child)

    try:
        repo.history(context, True)
        return
    except:
        # Not in repo
        pass

    version = queryAdapter(context, IObjectVersion)
    if version is not None:
        print "Updating version for %s" % model_path(context)
        repo.archive(version)

    container = queryAdapter(context, IContainerVersion)
    if container is not None:
        print "Updating container version for %s" % model_path(context)
        user = getattr(context, 'creator', None)
        if user is None:
            user = get_setting(context, 'system_user', 'admin')
        repo.archive_container(container, user)

    context._p_deactivate() # try not to run out of memory

def add_to_repo(obj, event):
    """
    Add a newly created object to the version repository.

    Intended use is as an IObjectAddedEvent subscriber.
    """
    repo = find_repo(obj)
    if repo is None:
        return

    try:
        # If we're undeleting an object, it might already be in the repo
        repo.history(obj.docid)
    except:
        # It is not in the repo, so add it
        adapter = queryAdapter(obj, IObjectVersion)
        if adapter is not None:
            if adapter.comment is None:
                adapter.comment = 'Content created.'
            repo.archive(adapter)

    container = event.parent
    adapter = queryAdapter(container, IContainerVersion)
    if adapter is not None:
        request = get_current_request()
        user = authenticated_userid(request)
        repo.archive_container(adapter, user)

    # Recurse into children if adding a subtree
    if IFolder.providedBy(obj):
        for name, child in obj.items():
            fake_event = FakeEvent()
            fake_event.parent = obj
            add_to_repo(child, fake_event)

    def __call__(self, **kwargs):
        PostOnly(self.request)
        form = self.request.form
        recurse = form.get('workflow_unarchive_recurse', False)

        context = self.context
        ploneview = getMultiAdapter((context, self.request), name='plone')
        if ploneview.isDefaultPageInFolder():
            context = self.context.getParentNode()

        if recurse:
            catalog = getToolByName(context, 'portal_catalog')
            query = {'path': '/'.join(context.getPhysicalPath())}
            brains = catalog.searchResults(query)

            for brain in brains:
                obj = brain.getObject()
                if IObjectArchived.providedBy(obj):
                    storage = queryAdapter(obj, IObjectArchivator)
                    storage.unarchive(obj)
            msg = "Object and contents have been unarchived"
        else:
            storage = queryAdapter(context, IObjectArchivator)
            storage.unarchive(context)
            msg = "Object has been unarchived"

        IStatusMessage(context.REQUEST).add(msg, 'info')

        return self.request.response.redirect(context.absolute_url())

def _back_references(source_object, attribute_name, translation=None):
    catalog = getUtility(ICatalog)
    intids = getUtility(IIntIds)

    lang = queryAdapter(source_object, ILanguage).get_language()
    if translation:
        lang = queryAdapter(translation, ILanguage).get_language()

    gsm = getSecurityManager()
    result = []
    for rel in catalog.findRelations({
            'to_id': intids.getId(aq_inner(source_object)),
            'from_attribute':attribute_name
        }):
        obj = intids.queryObject(rel.from_id)
        if obj is not None and checkPermission('zope2.View', obj):
            if ITranslatable.providedBy(obj):
                trans_manager = ITranslationManager(aq_inner(obj))
                try:
                    trans_obj = trans_manager.get_translation(lang)
                except Unauthorized, e:
                    continue

                if trans_obj:
                    result.append(trans_obj)
                    continue

            if gsm.checkPermission('zope2.View', obj):
                result.append(obj)

    def _handleReferences( self, baseline, wc, mode, wc_ref ):

        annotations = IAnnotations( wc_ref )

        baseline_adapter = interfaces.ICheckinCheckoutReference( baseline )

        # handle forward references
        for relationship in baseline.getRelationships():
            # look for a named relation adapter first
            adapter = component.queryAdapter(
                baseline, interfaces.ICheckinCheckoutReference, relationship )

            if adapter is None:  # default
                adapter = baseline_adapter

            references = baseline.getReferenceImpl( relationship )

            mode_method = getattr( adapter, mode )
            mode_method( baseline, wc, references, annotations )

        mode = mode + "BackReferences"

        # handle backward references
        for relationship in baseline.getBRelationships():
            adapter = component.queryAdapter(
                baseline, interfaces.ICheckinCheckoutReference, relationship )
            if adapter is None:
                adapter = baseline_adapter

            references = baseline.getBackReferenceImpl( relationship )

            mode_method = getattr( adapter, mode )
            mode_method( baseline, wc, references, annotations )

 def create_booking(self, order, cart_data, uid, count, comment):
     brain = get_catalog_brain(self.context, uid)
     # brain could be None if uid for item in cookie which no longer exists.
     if not brain:
         return
     buyable = brain.getObject()
     item_state = get_item_state(buyable, self.request)
     if not item_state.validate_count(count):
         msg = u'Item no longer available {0}'.format(buyable.id)
         logger.warning(msg)
         raise CheckoutError(msg)
     item_stock = get_item_stock(buyable)
     # stock not applied, state new
     if item_stock is None:
         available = None
         state = ifaces.STATE_NEW
     # calculate state from stock
     else:
         if item_stock.available is not None:
             item_stock.available -= float(count)
         available = item_stock.available
         state = ifaces.STATE_NEW if available is None or available >= 0.0\
             else ifaces.STATE_RESERVED
     item_data = get_item_data_provider(buyable)
     vendor = acquire_vendor_or_shop_root(buyable)
     booking = OOBTNode()
     booking.attrs['email'] = order.attrs['personal_data.email']
     booking.attrs['uid'] = uuid.uuid4()
     booking.attrs['buyable_uid'] = uid
     booking.attrs['buyable_count'] = count
     booking.attrs['buyable_comment'] = comment
     booking.attrs['order_uid'] = order.attrs['uid']
     booking.attrs['vendor_uid'] = uuid.UUID(IUUID(vendor))
     booking.attrs['creator'] = order.attrs['creator']
     booking.attrs['created'] = order.attrs['created']
     booking.attrs['exported'] = False
     booking.attrs['title'] = brain and brain.Title or 'unknown'
     booking.attrs['net'] = item_data.net
     booking.attrs['vat'] = item_data.vat
     booking.attrs['discount_net'] = item_data.discount_net(count)
     booking.attrs['currency'] = cart_data.currency
     booking.attrs['quantity_unit'] = item_data.quantity_unit
     booking.attrs['remaining_stock_available'] = available
     booking.attrs['state'] = state
     booking.attrs['salaried'] = ifaces.SALARIED_NO
     booking.attrs['tid'] = 'none'
     shipping_info = queryAdapter(buyable, IShippingItem)
     if shipping_info:
         booking.attrs['shippable'] = shipping_info.shippable
     else:
         booking.attrs['shippable'] = False
     trading_info = queryAdapter(buyable, ifaces.ITrading)
     if trading_info:
         booking.attrs['item_number'] = trading_info.item_number
         booking.attrs['gtin'] = trading_info.gtin
     else:
         booking.attrs['item_number'] = None
         booking.attrs['gtin'] = None
     return booking