def testExecuteCountMinMax(self):
     e = ChildCondition()
     e.check_types = set(['Document', 'Image'])
     e.wf_states = None
     e.recursive = False
     e.min_count = 2
     e.max_count = 3
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(False, ex())
     
     self.folder.invokeFactory('Document', 'd1')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(False, ex())
     
     self.folder.invokeFactory('Document', 'd2')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(True, ex())
     
     self.folder.invokeFactory('Document', 'd3')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(True, ex())
     
     self.folder.invokeFactory('Document', 'd4')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(False, ex())

    def test_delete_tile_persistent_data(self):
        permissions = getMultiAdapter(
            (self.tile.context, self.request, self.tile), ITilesPermissions)
        permissions.set_allowed_edit('masters_of_the_universe')
        annotations = IAnnotations(self.tile.context)
        self.assertIn('plone.tiles.permission.test-basic-tile', annotations)

        configuration = getMultiAdapter(
            (self.tile.context, self.request, self.tile),
            ITilesConfigurationScreen)
        configuration.set_configuration({
            'title': {'order': u'0', 'visibility': u'on'},
            'description': {'order': u'1', 'visibility': u'off'},
        })
        self.assertIn('plone.tiles.configuration.test-basic-tile',
                      annotations)

        # Call the delete method
        self.tile.delete()

        # Now we should not see the stored data anymore
        self.assertNotIn('plone.tiles.permission.test-basic-tile',
                         annotations)
        self.assertNotIn('plone.tiles.configuration.test-basic-tile',
                         annotations)

    def init(self):

        self.resizer = getMultiAdapter((self.context, self.request), IMobileImageProcessor)
        self.resizer.init()

        sniffer = getMultiAdapter((self.context, self.request), IUserAgentSniffer)
        self.ua = sniffer.getUserAgentRecord()

 def _add_rule_action(self, rule, action_id, data):
     action = component.getUtility(IRuleAction, name=action_id)
     adding = component.getMultiAdapter((rule, self.request),
                                        name='+action')
     addview = component.getMultiAdapter((adding, self.request),
                               name=action.addview)
     addview.createAndAdd(data=data)

 def __init__(self, context, request, view, manager):
     ViewletBase.__init__(self, context, request, view, manager)
     
     self.membership = getToolByName(self.context, 'portal_membership')        
     self.context_state = getMultiAdapter((context, request), name=u'plone_context_state')
     self.portal_state = getMultiAdapter((context, request), name=u'plone_portal_state')
     self.pas_info = getMultiAdapter((context, request), name=u'pas_info')

    def __init__(self, context, request):
        self.context = context
        self.request = request
        self.errors = {}

        self.portal_state = getMultiAdapter((self.context, self.request), name=u'plone_portal_state')
        self.tools = getMultiAdapter((self.context, self.request), name=u'plone_tools')
        self.props = getToolByName(self.context, 'portal_properties')
        self.utils = getToolByName(self.context, 'plone_utils')
        self.site_properties = self.props['site_properties']

        self.url_solicitacao_pesquisa = self.context.absolute_url()
        self.url_sucess = self.context.absolute_url()

        self.url_servico_ra = self.site_properties.URL_SERVICO_RA

        self.lista = []
        self.SiglaOsID = 'SUST'

        if 'ordemServico' in request.form:
            ordemServico = request.form['ordemServico']
            request.set('ordemServico', ordemServico)
            self.ordemServico = ordemServico
        else:
            self.ordemServico = None

        if 'anoOS' in request.form:
            anoOS = request.form['anoOS']
            request.set('anoOS', anoOS)
            self.anoOS = anoOS
        else:
            self.anoOS = None

    def getResults(self):
        context = Acquisition.aq_inner(self.context)

        # try to get query parameters from Topic (if present)
        query = hasattr(context, 'buildQuery') and context.buildQuery()
        if query:
            catalog = getToolByName(context, 'portal_catalog')
            results = catalog(query)
            # filter out results that are both outdated and expired
            to_show = [
                x for x in results if not (
                    getattr(x, 'outdated', False) and isExpired(x))
            ]
            return to_show

        # otherwise construct a query
        portal_state = getMultiAdapter(
            (self.context, self.request), name=u'plone_portal_state')
        navigation_root_path = portal_state.navigation_root_path()

        oshaview = getMultiAdapter(
            (self.context, self.request), name=u'oshaview')
        mySEP = oshaview.getCurrentSingleEntryPoint()
        kw = ''

        if mySEP:
            kw = mySEP.getProperty('keyword', '')

        query = '(portal_type:("News Item") OR isNews:true) AND '
        'review_state:published AND path_parents:%s' % navigation_root_path
        if kw != '':
            query = ' AND '.join([query, 'Subject:(%s)' % ' OR '.join(kw)])
        return search_solr(query, sort='Date desc')

    def getRepliesStructure(self):
        replyStructures = []

        isTask = self.getType() == 'Task'
        isDeadlinePassed = False
        outOfTime = False
        taskDeadline = getattr(self.context, 'deadline', None)
        if taskDeadline is not None:
            isDeadlinePassed = taskDeadline < datetime.datetime.now()

        for reply_brain in self.replies:
            reply = reply_brain.getObject()

            if not outOfTime and isTask and isDeadlinePassed:
                currentCreationDate = DT2dt(reply.created()).replace(tzinfo=None)
                if currentCreationDate > taskDeadline:
                    outOfTime = True
                    expiredView = getMultiAdapter(
                        (self.context, self.request), name=u"expired")
                    replyStructures.append(expiredView)

            view = getMultiAdapter((reply, self.request), name=u"thread")
            replyStructures.append(view)

        if replyStructures:
            replyStructures[-1].isLast = True

        if not outOfTime and isTask and isDeadlinePassed:
            expiredView = getMultiAdapter((self.context, self.request), name=u"expired")
            replyStructures.append(expiredView)

        return replyStructures

    def test_delete_tile_persistent_data(self):
        permissions = getMultiAdapter(
            (self.tile.context, self.request, self.tile), ITilesPermissions)
        permissions.set_allowed_edit('masters_of_the_universe')
        annotations = IAnnotations(self.tile.context)
        self.assertIn('plone.tiles.permission.test-pfg-tile', annotations)

        uuid = IUUID(self.pfg, None)
        configuration = getMultiAdapter(
            (self.tile.context, self.request, self.tile),
            ITilesConfigurationScreen)
        configuration.set_configuration({
            'uuid': uuid,
            'title': self.pfg.Title(),
            'description': self.pfg.Description(),
        })
        self.assertIn('plone.tiles.configuration.test-pfg-tile',
                      annotations)

        # Call the delete method
        self.tile.delete()

        # Now we should not see the stored data anymore
        self.assertNotIn('plone.tiles.permission.test-pfg-tile',
                         annotations)
        self.assertNotIn('plone.tiles.configuration.test-pfg-tile',
                         annotations)

    def update(self):
        context= aq_inner(self.context)

        context_helper = getMultiAdapter((context, self.request), name="plone_context_state")

        portal_helper = getMultiAdapter((context, self.request), name="plone_portal_state")

        canonical = context_helper.canonical_object()

        parent = aq_parent(canonical)

        breadcrumbs_view = getView(self.context, self.request, 'breadcrumbs_view')
        breadcrumbs = breadcrumbs_view.breadcrumbs()

        if (len(breadcrumbs)==1):
            self.backTitle = _(u"Home")
        else:
            if hasattr(parent, "Title"):
                self.backTitle = parent.Title()
            else:
                self.backTitle = _(u"Back")

        if hasattr(parent, "absolute_url"):
            self.backUrl = parent.absolute_url()
        else:
            self.backUrl = portal_helper.portal_url()

        self.isHome = len(breadcrumbs)==0

        self.homeUrl = portal_helper.portal_url()

    def test_spaces_are_not_escaped(self):
        # Escaping spaces in URLs with %20 in LaTeX is bad because % is a comment.
        chapter = create(Builder('chapter')
                         .within(self.book)
                         .titled('the chapter'))

        document = create(Builder('file')
                          .within(chapter)
                          .titled('The File')
                          .with_id('the file'))

        html = '<a class="internal-link" href="resolveuid/{0}">Link</a>'.format(
            IUUID(document))
        block = create(Builder('book textblock')
                       .within(chapter)
                       .having(text=html))

        request = block.REQUEST
        assembler = getMultiAdapter((self.book, request), IPDFAssembler)
        latex_view = getMultiAdapter((block, request, assembler.get_layout()),
                                     ILaTeXView)

        self.assertEqual(
            r'\hyperref[path:/plone/the-book/the-chapter/the file]{Link'
            r'\footnote{See page'
            r' \pageref{path:/plone/the-book/the-chapter/the file}}}',
            latex_view.render().strip())

 def __init__(self, context, request, view, manager, data):
     BaseRenderer.__init__(self, context, request, view, manager, data)
     portal_state = getMultiAdapter((context, request), name=u'plone_portal_state')
     portal_tools = getMultiAdapter((context, request), name=u'plone_tools')
     self.navigation_root_url = portal_state.navigation_root_url()
     self.portal_types = portal_tools.types()
     self.friendly_types = portal_state.friendly_types()

 def renderViewlet(self, manager, name):
     if isinstance(manager, basestring):
         manager = getMultiAdapter((self.context, self.request, self), IViewletManager, name=manager)
     renderer = getMultiAdapter((self.context, self.request, self, manager), IViewlet, name=name)
     renderer = renderer.__of__(self.context)
     renderer.update()
     return renderer.render()

 def testExecuteComplex(self):
     e = ChildCondition()
     e.check_types = set(['Folder', 'Document'])
     e.wf_states = set(['published'])
     e.recursive = True
     e.min_count = 2
     e.max_count = 3
     
     self.folder.invokeFactory('Folder', 'f1')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(False, ex())
     
     self.folder.f1.invokeFactory('Document', 'd1')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(False, ex())
     
     self.portal.portal_workflow.doActionFor(self.folder.f1, 'publish')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(False, ex())
     
     self.portal.portal_workflow.doActionFor(self.folder.f1.d1, 'publish')
     
     ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
     self.assertEquals(True, ex())

    def update(self):
        if not self.portal_state:
            self.portal_state = component.getMultiAdapter((self.context,
                                                           self.request),
                                           name="plone_portal_state")
        if not self.portal_url:
            self.portal_url = self.portal_state.portal_url()

        if self.portal_path is None:
            portal = self.portal_state.portal()
            self.portal_path = '/'.join(portal.getPhysicalPath())

        if self.portlet_url is None:
            #http://stackoverflow.com/questions/11211134/how-do-i-get-the-kind-of-portlet-group-context-type-from-its-renderer-in-pl/11211893#11211893
            retriever = component.getMultiAdapter((self.context, self.manager),
                                                  IPortletRetriever)
            category = None
            for info in retriever.getPortlets():
                if info['assignment'] is self.data.aq_base:
                    category = info['category']
                    key = info['key']
                    break
            if category is not None:
                path = key[len(self.portal_path)+1:]
                info = {'category': category,
                        'id': '%s' % self.data.id,
                        'manager': self.manager.__name__,
                        'context_path': path}
                self.portlet_url = '%s/%s' % (self.portal_url, 
                                              PORTLET_PATH % info)

    def test_exported_XML_valid_for_GS(self):
        """Test that exported XMLs can be parsed by GenericSetup's parser."""
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        # create a Dexterity item that we can export
        self.item = add_item_type(self.portal)

        # request is expected to have the 'selected' parameter set
        self.request['selected'] = 'item'

        # get the export view
        dexterity_control_panel = getMultiAdapter(
            (self.portal, self.request), name='dexterity-types')
        types_export_view = getMultiAdapter(
            (dexterity_control_panel, self.request), name='types-export')

        # export the 'item' type and try to parse all XMLs
        fd = StringIO.StringIO(types_export_view.__call__())
        archive = zipfile.ZipFile(fd, mode='r')
        filenames = archive.namelist()
        for filename in filenames:
            file_xml = archive.read(filename)

            # if this passes then GenericSetup will be able to use this XML
            try:
                parseString(file_xml)
            except ExpatError as e:
                self.fail("Parsing XML failed with ExpatError: " + e.message)

    def test_delete_confirmation_if_locked(self):
        folder = self.portal['f1']
        lockable = ILockable.providedBy(folder)

        form = getMultiAdapter(
            (folder, self.request), name='delete_confirmation')
        form.update()

        self.assertFalse(form.is_locked)

        if lockable:
            lockable.lock()

        form = getMultiAdapter(
            (folder, self.request), name='delete_confirmation')
        form.update()

        self.assertFalse(form.is_locked)

        # After switching the user it should not be possible to delete the
        # object. Of course this is only possible if our context provides
        # ILockable interface.
        if lockable:
            logout()
            login(self.portal, 'editor')

            form = getMultiAdapter(
                (folder, self.request), name='delete_confirmation')
            form.update()
            self.assertTrue(form.is_locked)

            logout()
            login(self.portal, TEST_USER_NAME)

            ILockable(folder).unlock()

    def test_crud(self):
        # we start with an empty tile
        self.assertTrue(self.tile.is_empty())

        # now we add a couple of objects to the list
        obj1 = self.portal['my-document']
        obj2 = self.portal['my-image']
        self.tile.populate_with_object(obj1)
        self.tile.populate_with_object(obj2)

        # tile's data attributed is cached so we should re-instantiate the tile
        tile = getMultiAdapter((self.cover, self.request), name=self.name)
        tile = tile['test']
        self.assertEqual(len(tile.results()), 2)
        self.assertTrue(obj1 in tile.results())
        self.assertTrue(obj2 in tile.results())

        # next, we replace the list of objects with a different one
        obj3 = self.portal['my-news-item']
        tile.replace_with_objects([IUUID(obj3, None)])
        # tile's data attributed is cached so we should re-instantiate the tile
        tile = getMultiAdapter((self.cover, self.request), name=self.name)
        tile = tile['test']
        self.assertTrue(obj1 not in tile.results())
        self.assertTrue(obj2 not in tile.results())
        self.assertTrue(obj3 in tile.results())

        # finally, we remove it from the list; the tile must be empty again
        tile.remove_item(obj3.UID())
        # tile's data attributed is cached so we should re-instantiate the tile
        tile = getMultiAdapter((self.cover, self.request), name=self.name)
        tile = tile['test']
        self.assertTrue(tile.is_empty())

    def get_values_to_index(self):
        request = getRequest()
        items = super(FactsheetCataloguer, self).get_values_to_index()
        view = getMultiAdapter((self.context, request), name='view')
        contents = u''
        for item in view.facts():
            for fact in item.get('facts'):
                contents += getMultiAdapter(
                    (fact.getObject(), request),
                    name='factrenderview')()

        items['article[content]'] = contents
        targets = []
        for target in (self.context.targets or []):
            targets.append(target)
        items['article[target_list]'] = u','.join(targets)
        actions = []
        for action in (self.context.actions or []):
            actions.append(action)
        items['article[action_list]'] = u','.join(actions)
        tags = []
        for tag in (self.context.cataloguetags or []):
            tagid, tagname = tag.split('-')
            tags.append(tagname)
        items['article[tag_list]'] = u','.join(tags)

        items['article[countries]'] = \
            (self.context.fact_countryCode or '').strip()

        return items

    def getResult(self):
        assert self._updated
        result = []
        qc = getMultiAdapter((self.context, self.request),
                             name='refbrowser_querycatalog')
        if self.widget.show_results_without_query or self.search_text:
            result = (self.widget.show_results_without_query or \
                      self.search_text) and \
                      qc(search_catalog=self.widget.search_catalog)

            self.has_queryresults = bool(result)

        elif self.widget.allow_browse:
            ploneview = getMultiAdapter((self.context, self.request),
                                        name="plone")
            folder = ploneview.getCurrentFolder()
            self.request.form['path'] = {
                              'query': '/'.join(folder.getPhysicalPath()),
                              'depth':1}
            self.request.form['portal_type'] = []
            self.request.form['sort_on'] = 'getObjPositionInParent'
            result = qc(search_catalog=self.widget.search_catalog)
        else:
            result = []
        b_size = int(self.request.get('b_size', 20))
        b_start = int(self.request.get('b_start', 0))

        return Batch(result, b_size, b_start, orphan=1)