コード例 #1
0
    def test_set_showroom_vars_correctly(self, browser):
        catalog = api.portal.get_tool('portal_catalog')

        base = create(Builder('dossier'))

        search_view = getMultiAdapter((self.portal, self.request), name="search")

        # Batch 1
        create(Builder('document').within(base).titled(u'A Foo'))
        create(Builder('dossier').within(base).titled(u'B Foo'))

        # Batch 2
        create(Builder('document').within(base).titled(u'C Foo'))
        create(Builder('document').within(base).titled(u'D Foo'))

        # Batch 3
        create(Builder('dossier').within(base).titled(u'E Foo'))
        create(Builder('document').within(base).titled(u'F Foo'))

        brains = catalog({'sort_on': 'sortable_title', 'SearchableText':"Foo"})

        search_view.calculate_showroom_configuration(IContentListing(brains[:2]))
        self.assertEqual(1, search_view.number_of_documents)
        self.assertEqual(0, search_view.offset)

        search_view.calculate_showroom_configuration(IContentListing(brains[2:4]))
        self.assertEqual(2, search_view.number_of_documents)
        self.assertEqual(0, search_view.offset)

        search_view.calculate_showroom_configuration(IContentListing(brains[4:]))
        self.assertEqual(1, search_view.number_of_documents)
        self.assertEqual(0, search_view.offset)
コード例 #2
0
    def test_set_showroom_vars_correctly(self, browser):
        self.login(self.regular_user, browser=browser)

        catalog = api.portal.get_tool('portal_catalog')
        search_view = getMultiAdapter((self.portal, self.request),
                                      name="search")

        brains = catalog({
            'portal_type': 'opengever.document.document',
            'sort_on': 'sortable_title',
            'SearchableText': "Foo"
        })

        brains = [
            obj2brain(obj)
            for obj in [self.document, self.dossier, self.subdocument]
        ]
        search_view.calculate_showroom_configuration(IContentListing(brains))
        self.assertEqual(2, search_view.number_of_documents)
        self.assertEqual(0, search_view.offset)

        brains = [obj2brain(obj) for obj in [self.task, self.subdossier]]
        search_view.calculate_showroom_configuration(IContentListing(brains))
        self.assertEqual(0, search_view.number_of_documents)
        self.assertEqual(0, search_view.offset)
コード例 #3
0
    def catalogResults(self, query, batch=True, b_size=20, b_start=0):
        """
        Make the search on portal_catalog instead solr
        """

        try:
            results = self.doSearch(query)
        except ParseError:
            return {}
        res_dict = {}
        filtered_results = []
        res_dict = {'tot_results_len': results.actual_result_count}
        active_tab = self.context.REQUEST.form.get('filter_tab')
        if active_tab:
            filtered_results = self.doFilteredSearch(active_tab, query)
        else:
            if self.tabs_order[0] != 'all':
                for tab_id in self.tabs_order:
                    filtered_results = self.doFilteredSearch(tab_id, query)
                    if filtered_results:
                        break
        filtered_infos, available_tabs = self.getFilterInfos(
            results, filtered_results)
        if filtered_results:
            results = IContentListing(filtered_results)
        else:
            results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        res_dict['results'] = results
        if filtered_infos:
            res_dict['indexes_dict'] = filtered_infos
        res_dict['tabs'] = available_tabs
        return res_dict
コード例 #4
0
    def _makequery(self, query=None, batch=False, b_start=0, b_size=30,
                   sort_on=None, sort_order=None, limit=0, brains=False):
        """Parse the (form)query and return using multi-adapter"""
        parsedquery = queryparser.parseFormquery(
            self.context, query, sort_on, sort_order)

        if not parsedquery:
            if brains:
                return []
            else:
                return IContentListing([])

        catalog = getToolByName(self.context, self.catalog_name)
        if batch:
            parsedquery['b_start'] = b_start
            parsedquery['b_size'] = b_size
        elif limit:
            parsedquery['sort_limit'] = limit

        if 'path' not in parsedquery:
            parsedquery['path'] = {'query': ''}
        parsedquery['path']['query'] = getNavigationRoot(self.context) + \
            parsedquery['path']['query']

        results = catalog(parsedquery)
        if not brains:
            results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #5
0
    def _makequery(self,
                   query=None,
                   batch=False,
                   b_start=0,
                   b_size=30,
                   sort_on=None,
                   sort_order=None,
                   limit=0,
                   brains=False):
        """Parse the (form)query and return using multi-adapter"""
        parsedquery = queryparser.parseFormquery(self.context, query, sort_on,
                                                 sort_order)
        index_modifiers = getUtilitiesFor(IParsedQueryIndexModifier)
        for name, modifier in index_modifiers:
            if name in parsedquery:
                new_name, query = modifier(parsedquery[name])
                parsedquery[name] = query
                # if a new index name has been returned, we need to replace
                # the native ones
                if name != new_name:
                    del parsedquery[name]
                    parsedquery[new_name] = query

        # Check for valid indexes
        catalog = getToolByName(self.context, 'portal_catalog')
        valid_indexes = [
            index for index in parsedquery if index in catalog.indexes()
        ]

        # We'll ignore any invalid index, but will return an empty set if none
        # of the indexes are valid.
        if not valid_indexes:
            logger.warning(
                "Using empty query because there are no valid indexes used.")
            parsedquery = {}

        if not parsedquery:
            if brains:
                return []
            else:
                return IContentListing([])

        if batch:
            parsedquery['b_start'] = b_start
            parsedquery['b_size'] = b_size
        elif limit:
            parsedquery['sort_limit'] = limit

        if 'path' not in parsedquery:
            parsedquery['path'] = {'query': ''}

        results = catalog(**parsedquery)

        if not brains:
            results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, start=b_start)
        return results
コード例 #6
0
    def _makequery(self, query=None, batch=False, b_start=0, b_size=30,
                   sort_on=None, sort_order=None, limit=0, brains=False):
        """Parse the (form)query and return using multi-adapter"""
        parsedquery = queryparser.parseFormquery(
            self.context, query, sort_on, sort_order)
        if not parsedquery:
            if brains:
                return []
            else:
                return IContentListing([])

        catalog = getToolByName(self.context, 'portal_catalog')
        if batch:
            parsedquery['b_start'] = b_start
            parsedquery['b_size'] = b_size
        elif limit:
            parsedquery['sort_limit'] = limit

        if 'path' not in parsedquery:
            parsedquery['path'] = {'query': ''}

        # The Subject field in Plone currently uses a utf-8 encoded string.
        # When a catalog query tries to compare a unicode string from the
        # parsedquery with existing utf-8 encoded string indexes unindexing
        # will fail with a UnicodeDecodeError. To prevent this from happening
        # we always encode the Subject query.
        # XXX: As soon as Plone uses unicode for all indexes, this code can
        # be removed.
        if 'Subject' in parsedquery:
            query = parsedquery['Subject']['query']
            # query can be a unicode string or a list of unicode strings.
            if isinstance(query, unicode):
                parsedquery['Subject']['query'] = query.encode("utf-8")
            elif isinstance(query, list):
                # We do not want to change the collections' own query string,
                # therefore we create a new copy of the list.
                copy_of_query = list(query)
                # Iterate over all query items and encode them if they are
                # unicode strings
                i = 0
                for item in copy_of_query:
                    if isinstance(item, unicode):
                        copy_of_query[i] = item.encode("utf-8")
                    i += 1
                parsedquery['Subject']['query'] = copy_of_query
            else:
                pass

        results = catalog(parsedquery)
        if not brains:
            results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #7
0
    def experimentslisting(self):
        site_path = queryUtility(IPloneSiteRoot).getPhysicalPath()
        b_start = self.request.get('b_start', 0)
        b_size = self.request.get('b_size', 20)
        experiment_type = self.request.get('datasets.filter.experimenttype',
                                           None)
        query = {
            'path': {
                'query':
                '/'.join(site_path + (defaults.EXPERIMENTS_FOLDER_ID, ))
            },
            'object_provides': experiment_type,
            'sort_on': 'created',
            'sort_order': 'descending',
            # provide batch hints to catalog
            'b_start': b_start,
            'b_size': b_size
        }

        text = self.request.get('datasets.filter.text')
        if text:
            query['SearchableText'] = text

        pc = getToolByName(self.context, 'portal_catalog')
        results = pc.searchResults(query)
        from Products.CMFPlone import Batch

        return Batch(IContentListing(results), b_size, b_start)
コード例 #8
0
    def _serialize_excerpts(self, meeting, item):
        excerpt_data = []

        docs = IContentListing(item.get_excerpt_documents(unrestricted=True))
        source_dossier_excerpt = item.get_source_dossier_excerpt()
        meeting_dossier = self.meeting.get_dossier()

        for doc in docs:
            data = {'link': doc.render_link()}
            if not source_dossier_excerpt and item.has_proposal:
                if self.meeting.is_editable():
                    data['return_link'] = meeting.get_url(
                        view='agenda_items/{}/return_excerpt?document={}'.
                        format(item.agenda_item_id, doc.uuid()))

            elif source_dossier_excerpt and doc == source_dossier_excerpt:
                data['is_excerpt_in_source_dossier'] = True

            if self._can_add_task_to_meeting_dossier():
                data['create_task_url'] = addTokenToUrl(
                    '{}/++add++opengever.task.task?paths:list={}'.format(
                        meeting_dossier.absolute_url(), doc.getPath()))

            excerpt_data.append(data)

        return excerpt_data
コード例 #9
0
 def _makequery(self,
                query=None,
                batch=False,
                b_start=0,
                b_size=30,
                sort_on=None,
                sort_order=None,
                limit=0,
                brains=False,
                custom_query=None):
     results = super(QueryBuilder,
                     self)._makequery(query,
                                      batch=False,
                                      b_start=b_start,
                                      b_size=b_size,
                                      sort_on=sort_on,
                                      sort_order=sort_order,
                                      limit=limit,
                                      brains=True,
                                      custom_query=custom_query)
     sorting = self.request.form.get('sorting', '')
     # if sorting is None make it an empty list
     sorting = isinstance(sorting, basestring) and sorting.split(',') or []
     # apply the custom sorting to the resultset according to
     # our sorting list
     positions = {j: i for i, j in enumerate(sorting)}
     results = sorted(results,
                      key=lambda item: positions.get(item.UID, 999))
     if not brains:
         results = IContentListing(results)
     if batch:
         results = Batch(results, b_size, start=b_start)
     return results
コード例 #10
0
def get_examples(context, limit=None, osh_related_only=False):
    """Return ToolExample objects contained in the provided context.

    :param context: object where to look for tool examples.
    :param limit: limit the number of results
    :returns: A list of published tool examples, sorted by date, latest first.
    :rtype: ContentListing object
    """
    path = context.getPhysicalPath()
    path = "/".join(path)
    query = {
        'path': {
            "query": path
        },
        'portal_type': 'osha.campaigntoolkit.toolexample',
        'review_state': 'published',
        'sort_on': 'Date',
        'sort_order': 'reverse'
    }
    if osh_related_only:
        query['OSH_related'] = True

    if context == context.portal_url.getPortalObject():
        return IContentListing(context.portal_catalog(query)[:limit])

    if not context.restrictedTraverse('@@folderListing', None):
        return None
    if limit is not None:
        query['sort_limit'] = limit
        return context.restrictedTraverse('@@folderListing')(**query)[:limit]
    else:
        return context.restrictedTraverse('@@folderListing')(**query)
コード例 #11
0
    def results(self, query=None, batch=True, b_size=10, b_start=0,
                use_content_listing=True):
        """ Get properly wrapped search results from the catalog.
        Everything in Plone that performs searches should go through this view.
        'query' should be a dictionary of catalog parameters.
        """
        if query is None:
            query = {}
        query['portal_type'] = 'llentry'
        # if self.request.form.get('customer','') == 'All':
        #     del self.request.form['customer']
        if batch:
            query['b_start'] = b_start = int(b_start)
            query['b_size'] = b_size
        query = self.filter_query(query)

        advanced_query = self.transform_query(query)
        if query is None:
            results = []
        else:
            catalog = getToolByName(self.context, 'portal_catalog')
            try:
                results = catalog.evalAdvancedQuery(advanced_query)
            except ParseError:
                return []

        if use_content_listing:
            results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #12
0
ファイル: statusview.py プロジェクト: ade25/wigo
 def recorded_incidents(self):
     catalog = api.portal.get_tool(name='portal_catalog')
     items = catalog(object_provides=IIncidentRecord.__identifier__,
                     sort_on='modified',
                     sort_order='reverse',
                     limit=50)[:50]
     return IContentListing(items)
コード例 #13
0
ファイル: patches.py プロジェクト: oikoumene/wcc.common
    def results(self, query=None, batch=True, b_size=10, b_start=0):
        results = _orig_results(self, query, batch, b_size, b_start)
        if not results:
            return results

        if query is None:
            query = {}

        query = self.filter_query(query)

        if not 'SearchableText' in query:
            return results

        if query.get('sort_on', ''):
            return results

        if batch:
            items = results._sequence._basesequence
        else:
            items = results._basesequence

        searchtext = query.get('SearchableText', '').lower().strip()
        sortkey = relevance_sortkey_factory(searchtext)
        items = list(sorted(items, key=sortkey, reverse=True))

        results = IContentListing(items)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #14
0
    def results(self, batch=True, b_size=16, b_start=0):
        """Return latests media on the site"""
        query = {
            'sort_on': 'Date',
            'sort_order': 'reverse',
        }
        if batch:
            b_start = int(b_start)

        text = self.request.form.get('SearchableText', '')
        if text:
            query['SearchableText'] = quote_chars(text)

        portal_type = self.request.form.get('portal_type', '')
        portal_type = self.filter_types(portal_type)
        query['portal_type'] = self.filter_types(portal_type)

        created = self.request.form.get('created', {})
        if self.valid_period(created):
            query['created'] = created

        # TODO: include results in current context only
        results = api.content.find(**query)
        results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #15
0
 def __getitem__(self, index):
     """`x.__getitem__(index)` <==> `x[index]`
     """
     if isinstance(index, slice):
         return IContentListing(
             self._basesequence[index.start:index.stop:index.step])
     return IContentListingObject(self._basesequence[index])
コード例 #16
0
 def __call__(self, **kw):
     query = {}
     query.update(**kw)
     query.setdefault('portal_type', 'Product')
     catalog = getToolByName(self.context, 'portal_catalog')
     results = catalog(query)
     return IContentListing(results)
コード例 #17
0
ファイル: search.py プロジェクト: FHNW/ftw.solr
    def results(self, query=None, batch=True, b_size=10, b_start=0):
        """Get properly wrapped search results from the catalog.
        'query' should be a dictionary of catalog parameters.
        """
        # Disable theming for ajax requests
        if 'ajax' in self.request.form:
            del self.request.form['ajax']
            self.request.response.setHeader('X-Theme-Disabled', 'True')

        if query is None:
            query = {}

        query['b_start'] = b_start = int(b_start)
        query['b_size'] = b_size
        query = self.filter_query(query)

        if query is None:
            results = []
        else:
            query.update({'qt': 'hlsearch'})
            catalog = getToolByName(self.context, 'portal_catalog')
            try:
                results = catalog(**query)
            except ParseError:
                logger.exception('Exception while searching')
                return []
            except SolrException:
                logger.exception('Exception while searching')
                return []

        self.solr_response = results
        results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #18
0
    def results(self, query=None, batch=True, b_size=10, b_start=0):
        """ Get properly wrapped search results from the catalog.
        Everything in Plone that performs searches should go through this view.
        'query' should be a dictionary of catalog parameters.
        """
        if query is None:
            query = {}
        if batch:
            query['b_start'] = b_start = int(b_start)
            query['b_size'] = b_size
        query = self.filter_query(query)

        if query is None:
            results = []
        else:
            catalog = getToolByName(self.context, 'portal_catalog')
            try:
                results = catalog(**query)
            except ParseError:
                return []

        results = IContentListing(results)
        if batch:
            results = Batch(results, b_size, b_start)
        return results
コード例 #19
0
 def results(self, **kwargs):
     """ Faceted results
     """
     kwargs['batch'] = False
     results = self.query(**kwargs)
     results = IContentListing(results)
     return results
コード例 #20
0
    def manually_generated_excerpts(self):
        docs = [
            excerpt.resolve_document()
            for excerpt in self.model.excerpt_documents
        ]

        return IContentListing(docs)
コード例 #21
0
    def documents(self):
        """ Return containing documents and related documents
        """
        def _get_documents():
            """ Return documents in this task and subtasks
            """
            documents = getToolByName(self.context, 'portal_catalog')(
                portal_type=[
                    'opengever.document.document',
                    'ftw.mail.mail',
                ],
                path=dict(depth=2,
                          query='/'.join(self.context.getPhysicalPath())),
            )
            return [document.getObject() for document in documents]

        def _get_related_documents():
            """ Return related documents in this task
            """
            # Related documents
            related_documents = []
            for item in self.context.relatedItems:
                obj = item.to_object
                if obj.portal_type in [
                        'opengever.document.document', 'ftw.mail.mail'
                ]:
                    obj._v__is_relation = True
                    related_documents.append(obj)
            return related_documents

        # merge and sort the two different lists
        document_list = _get_documents() + _get_related_documents()
        document_list.sort(lambda a, b: cmp(b.modified(), a.modified()))

        return IContentListing(document_list)
コード例 #22
0
    def getFoldersAndImages(self):
        """Get folders and images"""
        catalog = getToolByName(self, 'portal_catalog')
        results = self.results(batch=False)

        _mapping = {'results': results, 'images': {}, 'others': []}
        portal_atct = getToolByName(self, 'portal_atct')
        image_types = getattr(portal_atct, 'image_types', [])

        for item in results:
            item_path = item.getPath()
            if item.isPrincipiaFolderish:
                query = {
                    'portal_type': image_types,
                    'path': item_path,
                }
                _mapping['images'][item_path] = IContentListing(catalog(query))
            elif item.portal_type in image_types:
                _mapping['images'][item_path] = [
                    item,
                ]
            else:
                _mapping['others'].append(item._brain)

        _mapping['total_number_of_images'] = sum(
            map(len, _mapping['images'].values()))
        return _mapping
コード例 #23
0
 def __getslice__(self, i, j):
     """`x.__getslice__(i, j)` <==> `x[i:j]`
     Use of negative indices is not supported.
     No longer used in Python 3, but still part of
     zope.interface.interfaces.IReadSequence
     """
     return IContentListing(self._basesequence[i:j])
コード例 #24
0
    def _serialize_submitted_documents(self, item):
        """Returns a list of html strings (the complete document link).
        """
        if not item.has_proposal:
            return []

        docs = IContentListing(item.proposal.resolve_submitted_documents())
        return [doc.render_link() for doc in sorted(docs, key=lambda doc: doc.title_or_id().lower())]
コード例 #25
0
 def documents(self):
     return IContentListing(
         self.catalog([
             'opengever.document.document',
             'ftw.mail.mail',
         ],
                      sort_on='sortable_title',
                      sort_order='asc')[:self.document_limit])
コード例 #26
0
    def _serialize_submitted_documents(self, item):
        """Returns a list of html strings (the complete document link).
        """
        if not item.has_proposal:
            return []

        docs = IContentListing(item.proposal.resolve_submitted_documents())
        return [doc.render_link() for doc in docs]
コード例 #27
0
 def results(self, **kwargs):
     """ Faceted results
     """
     kwargs['batch'] = False
     results = self.query(**kwargs)
     if isinstance(results, GeneratorType):
         results = [i for i in results]
     results = IContentListing(results)
     return results
コード例 #28
0
ファイル: viewlet.py プロジェクト: talkara/santa.templates
 def _items(self, brains):
     return [{
         'title': item.Title(),
         'url': item.getURL(),
         'description': item.Description(),
         'date': self._date(item),
         'end': self._end(item),
         'image': self.image(item),
     } for item in IContentListing(brains)]
コード例 #29
0
 def conferenceTrack(self):
     results = []
     for rel in self.context.conferencetrack:
         if rel.isBroken():
             # skip broken relations
             continue
         obj = rel.to_object
         if api.user.has_permission('View', obj=obj):
             results.append(obj)
     return IContentListing(results)
コード例 #30
0
 def workshopLeaders(self):
     results = []
     for rel in self.context.speaker:
         if rel.isBroken():
             # skip broken relations
             continue
         obj = rel.to_object
         if api.user.has_permission('View', obj=obj):
             results.append(obj)
     return IContentListing(results)
コード例 #31
0
    def getSearchDestinationList(self, type_=None):
        """ Return list of destinatons """
        catalog = getToolByName(self.context, 'portal_catalog')

        portal = api.portal.get()
        container_path = '/'.join(portal.getPhysicalPath())

        query = (MatchGlob('Title',
                    self.request.get('SearchableText', '') + '*') | \
                MatchGlob('Description', 
                    self.request.get('SearchableText', '') + '*')) & \
                Eq('path', container_path) & \
                In('portal_type', self._get_container_types())

        obj = lambda o: o if ISiteRoot.providedBy(o) else o.getObject()

        results = IContentListing(catalog.evalAdvancedQuery(query))
        results = [self._info_from_content(x) for x in results
                   if self._is_container_selectable(obj(x), type_)]
        results.sort(lambda x, y: cmp(x['title'], y['title']))
        return simplejson.dumps(results)
コード例 #32
0
    def get_tree(self, uid=None, type_=None):
        if type_ is None:
            type_ = self.request.get('type_', None)

        catalog = getToolByName(self.context, 'portal_catalog')

        container_path = ''
        if uid is not None:
            container = catalog(UID=uid)
            if len(container) == 1:
                container = container[0]
                container_path = container.getPath()

        if not container_path:
            portal = api.portal.get()
            container_path = '/'.join(portal.getPhysicalPath())

        query = {'portal_type': self._get_container_types(),
                 'path': {'query': container_path, 'depth': 1}}

        results = IContentListing(catalog(**query))
        results = [self._info_from_content(x, type_) for x in results]
        results.sort(lambda x, y: cmp(x['title'], y['title']))
        return results