def __call__(self, context, query=None): parsed = {} if query: parsed = queryparser.parseFormquery(context, query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) try: catalog = getToolByName(context, 'portal_catalog') except AttributeError: context = getSite() catalog = getToolByName(context, 'portal_catalog') # If no path is specified check if we are in a sub-site and use that # as the path root for catalog searches if 'path' not in parsed: portal = getToolByName(context, 'portal_url').getPortalObject() nav_root = getNavigationRootObject(context, portal) if nav_root.getPhysicalPath() != portal.getPhysicalPath(): parsed['path'] = { 'query': '/'.join(nav_root.getPhysicalPath()), 'depth': -1 } brains = catalog(**parsed) return CatalogVocabulary.fromItems(brains, context)
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): """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': ''} if isinstance(custom_query, dict): # Update the parsed query with extra query dictionary. This may # override parsed query options. parsedquery.update(custom_query) results = catalog(**parsedquery) if getattr(results, 'actual_result_count', False) and limit\ and results.actual_result_count > limit: results.actual_result_count = limit if not brains: results = IContentListing(results) if batch: results = Batch(results, b_size, start=b_start) return results
def generate_query_for_events(self): data = json_body(self.request) parsed_query = queryparser.parseFormquery(context=self.context, formquery=data["query"]) fullobjects = data.get("fullobjects", False) b_size = data.get("b_size", None) b_start = data.get("b_start", 0) query = { k: v for k, v in parsed_query.items() if k not in ["start", "end"] } limit = int(data.get("limit", 1000)) sort = "start" sort_reverse = False start, end = self.parse_event_dates(parsed_query) if data.get("sort_on", ""): sort = data["sort_on"] if data.get("sort_order", ""): sort_reverse = data["sort_order"] == "descending" and True or False return ( start, end, fullobjects, b_size, b_start, query, sort_reverse, sort, limit, )
def __call__(self, context, query=None): query = query or {} if 'criteria' not in query: query['criteria'] = [] query['criteria'].append( {u'i': u'portal_type', u'o': u'plone.app.querystring.operation.selection.is', u'v': [u'eea.climateadapt.adaptationoption']} ) parsed = {} if query: parsed = queryparser.parseFormquery(context, query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) try: catalog = getToolByName(context, 'portal_catalog') except AttributeError: catalog = getToolByName(getSite(), 'portal_catalog') if parsed.get('path'): if parsed['path'].get('depth'): parsed['path']['query'].append(u'/cca/metadata/adaptation-options') if u'/cca' in parsed['path']['query']: parsed['path']['query'].remove(u'/cca') brains = catalog(**parsed) return CatalogVocabulary.fromItems(brains, context)
def get_items(self): context = aq_inner(self.context) res = "" if IATFolder.providedBy(context) or \ IATBTreeFolder.providedBy(context): res = self.context.getFolderContents( contentFilter={ 'sort_on': 'getObjPositionInParent', 'portal_type': self.settings.allowed_types, 'limit': self.settings.limit }) elif IATTopic.providedBy(context): if self.settings.limit and self.settings.limit > 0: res = context.queryCatalog( batch=True, b_size=self.settings.limit, portal_type=self.settings.allowed_types, ) else: res = context.queryCatalog( portal_type=self.settings.allowed_types, limit=self.settings.limit) elif ICollection.providedBy(context): query = queryparser.parseFormquery(context, context.getRawQuery()) query['portal_type'] = self.settings.allowed_types query['limit'] = self.settings.limit if self.settings.limit and self.settings.limit > 0: res = context.queryCatalog(batch=True, b_size=self.settings.limit) else: res = context.queryCatalog(query) return res
def get_items(self): context = aq_inner(self.context) if IATFolder.providedBy(context) or \ IATBTreeFolder.providedBy(context): res = self.context.getFolderContents( contentFilter={ 'sort_on': 'getObjPositionInParent', 'portal_type': self.settings.allowed_types, 'limit': self.settings.limit } ) elif IATTopic.providedBy(context): if self.settings.limit and self.settings.limit > 0: res = context.queryCatalog(batch=True, b_size=self.settings.limit, portal_type= self.settings.allowed_types, ) else: res = context.queryCatalog( portal_type=self.settings.allowed_types, limit=self.settings.limit ) elif ICollection.providedBy(context): query = queryparser.parseFormquery( context, context.getRawQuery()) query['portal_type'] = self.settings.allowed_types query['limit'] = self.settings.limit if self.settings.limit and self.settings.limit > 0: res = context.queryCatalog(batch=True, b_size=self.settings.limit) else: res = context.queryCatalog(query) return res
def events(self, ret_mode=RET_MODE_ACCESSORS, expand=True, batch=True): res = [] is_col = self.is_collection is_top = self.is_topic if is_col or is_top: ctx = self.default_context if is_col: res = ctx.results(batch=False, sort_on='start', brains=True) query = queryparser.parseFormquery(ctx, ctx.getRawQuery()) else: res = ctx.queryCatalog(batch=False, full_objects=False) query = ctx.buildQuery() if expand: # get start and end values from the query to ensure limited # listing for occurrences start, end = self._expand_events_start_end(query.get('start'), query.get('end')) res = expand_events(res, ret_mode, sort='start', start=start, end=end) else: res = self._get_events(ret_mode, expand=expand) if batch: b_start = self.b_start b_size = self.b_size res = Batch(res, size=b_size, start=b_start, orphan=self.orphan) return res
def query(self, form): """ Get value from form and return a catalog dict query """ # we receive the UID of the selected Collection # get the collection, compute the query and return it collection_uid = form.get(self.data.__name__, '') if collection_uid and not collection_uid == 'all': # get the collection and compute the query catalog = getToolByName(self.context, 'portal_catalog') brains = catalog(UID=collection_uid) collection = brains[0].getObject() query = queryparser.parseFormquery(collection, collection.query) # use sort_on defined on the collection if it is # not already in the request.form # get the sort_on criterion and look in the request.form if it is used sort_on_is_used = False for criterion_id, criterion in self.criteria.items(): if criterion.widget == SortingWidget.widget_type: # criterion id in the request.form is like c0[] if "{0}[]".format(criterion_id) in self.request.form: sort_on_is_used = True break if not sort_on_is_used: if collection.sort_on: query['sort_on'] = collection.sort_on if collection.sort_reversed: query['sort_order'] = collection.sort_reversed and 'descending' or '' return query return {}
def events(self, ret_mode=RET_MODE_ACCESSORS, expand=True, batch=True): res = [] is_col = self.is_collection is_top = self.is_topic if is_col or is_top: ctx = self.default_context if is_col: res = ctx.results(batch=False, sort_on='start', brains=True) query = queryparser.parseFormquery(ctx, ctx.getRawQuery()) else: res = ctx.queryCatalog(batch=False, full_objects=False) query = ctx.buildQuery() if expand: # get start and end values from the query to ensure limited # listing for occurrences start, end = self._expand_events_start_end( query.get('start'), query.get('end')) res = expand_events(res, ret_mode, sort='start', start=start, end=end) else: res = self._get_events(ret_mode, expand=expand) if batch: b_start = self.b_start b_size = self.b_size res = Batch(res, size=b_size, start=b_start, orphan=self.orphan) return res
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': ''} 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
def parse_query_from_data(data, context=None): """Parse query from data dictionary""" if context is None: context = api.portal.get() query = data.get('query', {}) or {} try: parsed = queryparser.parseFormquery(context, query) except KeyError: parsed = {} index_modifiers = getUtilitiesFor(IParsedQueryIndexModifier) for name, modifier in index_modifiers: if name in parsed: new_name, query = modifier(parsed[name]) parsed[name] = query # if a new index name has been returned, we need to replace # the native ones if name != new_name: del parsed[name] parsed[new_name] = query if data.get('sort_on'): parsed['sort_on'] = data['sort_on'] if data.get('sort_reversed', False): parsed['sort_order'] = 'reverse' return parsed
def layers(self): layers = super(KMLFileTopicMapLayers, self).layers() lcount = len(layers) query = {'object_provides': IGisFile.__identifier__} #XXX if self.context.portal_type == 'Folder': brains = self.context.getFolderContents(contentFilter=query) elif self.context.portal_type == 'Collection': query.update(queryparser.parseFormquery( self.context, self.context.getRawQuery())) brains=self.portal_catalog(**query) elif self.context.portal_type == 'Topic': query.update(self.context.buildQuery()) brains=self.portal_catalog(**query) else: brains = [] logger.error('cannot get query for current object') for brain in brains: object = brain.getObject() if object.content_type in MIMETYPES: layers.append(KMLFileMapLayer(self.context, object, zoom_here=False)) if len(layers) > lcount: layers[-1].zoom_here = True return layers
def compute(self, collection_uid): """ """ res = {} # special case for the 'all' option where every criteria are kept if collection_uid == 'all': res = dict([(k, []) for k in self.widget.advanced_criteria]) else: catalog = getToolByName(self.context, 'portal_catalog') brains = catalog(UID=collection_uid) if brains: collection = brains[0].getObject() collection_criteria = queryparser.parseFormquery(collection, collection.query) advanced_criteria = self.widget.advanced_criteria for wid, index in advanced_criteria.items(): if index not in collection_criteria: res[wid] = [] else: enabled_checkboxes = collection_criteria[index].get('query', []) # special bypass for daterange, if we have a list of dates, we use [] if isinstance(catalog.Indexes.get(index), DateIndex) and \ isinstance(enabled_checkboxes, list): enabled_checkboxes = [] if isinstance(enabled_checkboxes, basestring): # the case {'Creator': {'query': 'test-user'}} go here enabled_checkboxes = [enabled_checkboxes] res[wid] = enabled_checkboxes return res
def get_subgalleries(self, **kwargs): def fix_query(parsedquery): 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 return parsedquery query = queryparser.parseFormquery(self.gallery, self.gallery.query) catalog = getToolByName(self.gallery, 'portal_catalog') if 'Subject' in kwargs: if 'Subject' not in query: query.update({'Subject': kwargs['Subject']}) else: query['Subject'] = {'operator': 'and', 'query': [kwargs['Subject']] + query['Subject']['query']} if 'object_provides' not in query: query.update({'object_provides': IGallery.__identifier__}) else: query['object_provides'] = {'operator': 'and', 'query': [IGallery.__identifier__] + query[ 'object_provides']['query']} query = fix_query(query) sort_order = ('reverse' if self.gallery.sort_reversed else 'ascending') b_size = self.gallery.item_count sort_on = self.gallery.sort_on limit = self.gallery.limit results = catalog(query, b_size=b_size, sort_on=sort_on, sort_order=sort_order, limit=limit, ) uid = IUUID(self.gallery, None) if uid is None: uid = self.gallery.UID() def afilter(i): """prevent same object and multiple nested galleries""" return i.UID != uid and \ getMultiAdapter((i.getObject(), self.request), name='plonetruegallery_util' ).enabled() return filter(afilter, results)
def test_path_explicit(self): data = { 'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': '/foo', } parsed = queryparser.parseFormquery(MockSite(), [data, ]) self.assertEqual(parsed, {'path': {'query': '/%s/foo' % MOCK_SITE_ID}})
def test_multiple_adapters(self): """We are able to select multiple values in the MultipleSelectionWidget.""" query = list(COMPOUND_QUERY) query[0]['v'] = ['testing-compound-adapter', 'portaltype-compound-adapter'] self.assertEqual( parseFormquery(self.portal, query), {'portal_type': {'query': ['Document', 'Folder']}, 'Title': {'query': u'special_text_to_find'}})
def test_exact_title(self): data = { 'i': 'Title', 'o': 'plone.app.querystring.operation.string.is', 'v': 'Welcome to Plone', } parsed = queryparser.parseFormquery(MockSite(), [data, ]) self.assertEqual(parsed, {'Title': {'query': 'Welcome to Plone'}})
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
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([]) if self.context.getField('useSolr').get(self.context): parsedquery['use_solr'] = True 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, start=b_start) return results
def filter_fields(self): fields = () d_vals = getattr(self.view, 'default_values', {}) p_query = queryparser.parseFormquery(self.context, self.context.query) try: trans_map = resolve_dottedname(api.portal.get_registry_record( 'kombinat.behavior.collectionfilter.translation_map')) except: # fallback trans_map = FILTER_TRANSLATION_MAP or {} try: vocab_map = resolve_dottedname(api.portal.get_registry_record( 'kombinat.behavior.collectionfilter.vocabulary_map')) except: # fallback vocab_map = FILTER_VOCABULARY_MAP or {} for idx in trans_map.keys(): if idx in (getattr(self.context, 'ignore_fields', []) or []): # visibility of filter fields continue qvals = p_query.get(idx, {}).get('query', []) i_sel = safe_unicode(self.request.get(idx) or d_vals.get(idx)) label_vocab = vocab_map.get(idx, lambda x: None)(self.context) def option_label(value): if label_vocab: try: return label_vocab.getTermByToken(value).title except: pass return translate(_pmf(value), context=self.request) if idx == 'path': vals = [] for v in qvals: try: loc_title = self.context.restrictedTraverse( v.encode('utf8')).Title() except Exception, msg: logger.info("error: {}".format(msg)) continue vals.append(dict(value=v, title=loc_title, selected=i_sel == v and 'selected' or '')) else: vals = [dict(value=v, title=option_label(v), selected=safe_unicode(i_sel) == v \ and 'selected' or '') for v in qvals if v] if not vals or len(vals) < 2: continue fields += (dict( name=idx, placeholder=translate(trans_map.get(idx, idx), context=self.request), options=sorted(vals, key=itemgetter('title')), ), )
def contents(self): """Search results""" parsedquery = queryparser.parseFormquery(self.context, self.query) accessor = getMultiAdapter((self.context, self.request), name='searchResults')(query=parsedquery) view = self.view_template view = view.encode('utf-8') options = dict(original_context=self.context) return getMultiAdapter((accessor, self.request), name=view)(**options)
def test_path_computed(self): data = { 'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': '00000000000000001', } parsed = queryparser.parseFormquery(MockSite(), [data, ]) self.assertEqual(parsed, {'path': {'query': '/site/foo'}})
def test_path_explicit(self): data = { 'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': '/foo', } parsed = queryparser.parseFormquery(MockSite(), [data, ]) self.assertEqual( parsed, {'path': {'query': ['/%s/foo' % MOCK_SITE_ID]}})
def getImageInformation(self): limit = self.context.limit query = queryparser.parseFormquery(self.context, self.context.getRawQuery()) query.update({'object_provides': IImageContent.__identifier__}) query['sort_limit'] = limit catalog = getToolByName(self.context, 'portal_catalog') images = catalog(query) images = images[:limit] return map(self.assemble_image_information, images)
def show_filter(self): ret = True if self.is_collection: ctx = self.default_context query = queryparser.parseFormquery(ctx, ctx.query) if 'start' in query or 'end' in query: # Don't show the date filter, if a date is given in the # collection's query ret = False return ret
def parsed_query(self,): query = _parseJSON(self.request.get("query", "")) or {} if query: parsed = queryparser.parseFormquery(self.get_context(), query["criteria"]) if "sort_on" in query: parsed["sort_on"] = query["sort_on"] if "sort_order" in query: parsed["sort_order"] = str(query["sort_order"]) query = parsed return query
def __call__(self, *args, **kw): """Render JS Initialization code""" response = self.request.response context = self.context response.setHeader('Content-Type', 'application/x-javascript') args = { 'start': { 'query': DateTime(self.request.get('end')), 'range': 'max'}, 'end': { 'query': DateTime(self.request.get('start')), 'range': 'min'}} if context.portal_type == 'Collection': rawquery = context.getRawQuery() query = parseFormquery(context, rawquery, sort_on=context.getSort_on()) query.update(args) catalog = getToolByName(context, 'portal_catalog') brains = catalog(query) elif context.portal_type == 'Topic': brains = context.aq_inner.queryCatalog(REQUEST=self.request, **args) else: portal_calendar = getToolByName(context, 'portal_calendar') catalog = getToolByName(context, 'portal_catalog') brains = catalog( portal_type=portal_calendar.getCalendarTypes(), path={'depth': -1, 'query': '/'.join(context.getPhysicalPath())} ) result = [] memberid = self.context.portal_membership.getAuthenticatedMember().id modifier = queryUtility(IFtwCalendarModifier) for brain in brains: if memberid in brain.Creator: editable = True else: editable = False duration = (brain.end - brain.start) * 86400 info = { "id": "UID_%s" % (brain.UID), "title": brain.Title, "start": brain.start.ISO8601(), "end": brain.end.ISO8601(), "url": brain.getURL(), "editable": editable, "allDay": duration >= 86340, "className": "state-" + str(brain.review_state) + (editable and " editable" or ""), "description": brain.Description } if modifier: modifier(brain, info) result.append(info) return json.dumps(result, sort_keys=True)
def parsed_query(self, ): query = _parseJSON(self.request.get('query', '')) or {} if query: parsed = queryparser.parseFormquery(self.get_context(), query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) query = parsed return query
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
def events(self): context = aq_inner(self.context) data = self.data query = {} if data.state: query['review_state'] = data.state events = [] query.update(self.request.get('contentFilter', {})) search_base = self.search_base if ICollection and ICollection.providedBy(search_base): # Whatever sorting is defined, we're overriding it. query = queryparser.parseFormquery( search_base, search_base.query, sort_on='start', sort_order=None ) start = None if 'start' in query: start = query['start'] else: start = localized_now(context) end = None if 'end' in query: end = query['end'] start, end = _prepare_range(search_base, start, end) query.update(start_end_query(start, end)) events = search_base.results( batch=False, brains=True, custom_query=query, limit=data.count ) events = expand_events( events, ret_mode=RET_MODE_ACCESSORS, start=start, end=end, sort='start', sort_reverse=False ) events = events[:data.count] # limit expanded else: search_base_path = self.search_base_path if search_base_path: query['path'] = {'query': search_base_path} events = get_events( context, start=localized_now(context), ret_mode=RET_MODE_ACCESSORS, expand=True, limit=data.count, **query ) eventlist=[] for ev in events: hasimage = bool(getattr(ev.context, 'image', None)) eventlist.append((ev, hasimage)) return eventlist
def parsed_query(self, ): query = _parseJSON(self.request.get('query', '')) or {} if query: parsed = queryparser.parseFormquery( self.get_context(), query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) query = parsed return query
def __call__(self, context, query=None): parsed = {} if query: parsed = queryparser.parseFormquery(context, query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) catalog = getToolByName(context, 'portal_catalog') brains = catalog(**parsed) return CatalogVocabulary.fromItems(brains, context)
def getResults(self, content, with_sticky=True): """Content is a Collection""" # Make a copy of the query to avoid modifying it query = list(content.query) index_view_keywords = getattr(content, 'index_view_keywords', False) # set query for homepage if index_view_keywords: homepage_keywords = content.index_view_keywords query.append({ 'i': 'hiddenTags', 'o': 'plone.app.querystring.operation.selection.is', 'v': homepage_keywords }) sort_on = getattr(content, 'sort_on', None) sort_order = 'reverse' if getattr(content, 'sort_reversed', False) else 'ascending' # noqa sort_reversed = getattr(content, 'sort_reversed', False) parsedquery = queryparser.parseFormquery( content, query, sort_on, sort_order ) portal_catalog = api.portal.get_tool('portal_catalog') brains = portal_catalog(parsedquery) item_count_homepage = getattr(content, 'item_count_homepage', 8) if self.is_event_collection(brains): start = DateTime() sort_on = getattr(content, 'sort_on', 'start') if sort_on in ('start', 'end'): filter_and_resort_brains = filter_and_resort( content, brains, start, None, sort_on, sort_reversed ) brains = filter_and_resort_brains[:item_count_homepage] brains = brains[:item_count_homepage] if not with_sticky: return brains portal_catalog = api.portal.get_tool(name='portal_catalog') results = {'sticky-results': [], 'standard-results': []} for brain in brains: if portal_catalog.getIndexDataForRID(brain.getRID())['is_sticky']: results['sticky-results'].append(brain) else: results['standard-results'].append(brain) if not results['sticky-results'] and not results['standard-results']: return None return results
def test_sort_on_unknown(self): data = { 'i': 'Title', 'o': 'plone.app.querystring.operation.string.is', 'v': 'Welcome to Plone', } parsed = queryparser.parseFormquery(MockSite(), [ data, ], sort_on='unknown', sort_order='reverse') self.assertEqual(parsed, {'Title': {'query': 'Welcome to Plone'}})
def query(self, form): """ Get value from form and return a catalog dict query """ # we receive the UID of the selected Collection # get the collection, compute the query and return it collection_uid = form.get(self.data.__name__, '') if collection_uid: # get the collection and compute the query catalog = getToolByName(self.context, 'portal_catalog') brains = catalog(UID=collection_uid) collection = brains[0].getObject() return queryparser.parseFormquery(self.context, collection.query) return {}
def events(self): context = aq_inner(self.context) data = self.data query = {} if data.state: query['review_state'] = data.state events = [] query.update(self.request.get('contentFilter', {})) search_base = self.search_base if ICollection and ICollection.providedBy(search_base): # Whatever sorting is defined, we're overriding it. query = queryparser.parseFormquery(search_base, search_base.query, sort_on='start', sort_order=None) start = None if 'start' in query: start = query['start'] else: start = localized_now(context) end = None if 'end' in query: end = query['end'] start, end = _prepare_range(search_base, start, end) query.update(start_end_query(start, end)) events = search_base.results(batch=False, brains=True, custom_query=query, limit=data.count) events = expand_events(events, ret_mode=RET_MODE_ACCESSORS, start=start, end=end, sort='start', sort_reverse=False) events = events[:data.count] # limit expanded else: search_base_path = self.search_base_path if search_base_path: query['path'] = {'query': search_base_path} events = get_events(context, start=localized_now(context), ret_mode=RET_MODE_ACCESSORS, expand=True, limit=data.count, **query) return events
def _getCriteriaArgs(self): context, request = self.context, self.request response = request.response listCriteria = context.query query = dict([ (key, convert(value)) for key, value in queryparser.parseFormquery(context, listCriteria).items() ]) topicCriteria = interfaces.IListCriterias(context)() _args = {} if not query: return ({}, []) props = getToolByName(context, 'portal_properties') charset = props and props.site_properties.default_charset or 'utf-8' if 'Type' in query.keys(): items = getCookieItems(request, 'Type', charset) if items: _args['Type'] = items else: _args['Type'] = query['Type'] filters = [] #reinit cookies if criterions are no more there for cId in [c['i'] for c in listCriteria]: if cId not in topicCriteria.keys(): response.expireCookie(cId) if request.cookies.get('sfqueryDisplay', None) not in topicCriteria.keys(): response.expireCookie('sfqueryDisplay') for criteria in listCriteria: criteriaId = criteria['i'] if criteria['o'] not in \ ['plone.app.querystring.operation.selection.is', 'plone.app.querystring.operation.list.contains'] \ and criteriaId != 'portal_type': _args[criteriaId] = query[criteriaId] else: items = getCookieItems(request, criteriaId, charset) if items and criteriaId in topicCriteria.keys(): if 'undefined' in items: filters.append({'name':criteriaId, 'values':items}) else: _args[criteriaId] = items else: _args[criteriaId] = query[criteriaId] return _args, filters
def _getCriteriaArgs(self): context, request = self.context, self.request response = request.response listCriteria = context.query query = dict([(key, convert(value)) for key, value in queryparser.parseFormquery( context, listCriteria).items()]) topicCriteria = interfaces.IListCriterias(context)() _args = {} if not query: return ({}, []) props = getToolByName(context, 'portal_properties') charset = props and props.site_properties.default_charset or 'utf-8' if 'Type' in query.keys(): items = getCookieItems(request, 'Type', charset) if items: _args['Type'] = items else: _args['Type'] = query['Type'] filters = [] #reinit cookies if criterions are no more there for cId in [c['i'] for c in listCriteria]: if cId not in topicCriteria.keys(): response.expireCookie(cId) if request.cookies.get('sfqueryDisplay', None) not in topicCriteria.keys(): response.expireCookie('sfqueryDisplay') for criteria in listCriteria: criteriaId = criteria['i'] if criteria['o'] not in \ ['plone.app.querystring.operation.selection.is', 'plone.app.querystring.operation.list.contains'] \ and criteriaId != 'portal_type': _args[criteriaId] = query[criteriaId] else: items = getCookieItems(request, criteriaId, charset) if items and criteriaId in topicCriteria.keys(): if 'undefined' in items: filters.append({'name': criteriaId, 'values': items}) else: _args[criteriaId] = items else: _args[criteriaId] = query[criteriaId] return _args, filters
def get_contettypes(self): collectionobj = self.context contents = {} portal_types = getToolByName(self.context, "portal_types") query = queryparser.parseFormquery(collectionobj, collectionobj.getRawQuery()) if 'portal_type' in query.keys() and 'query' in query['portal_type'].keys(): for ct in query['portal_type']['query']: ct_name = ct if ct in portal_types.keys(): ct_name = portal_types[ct].title contents[ct] = ct_name return contents
def _set_query_base_search(self): """ """ query = {} form = self.request.form base_search_uid = form.get("base_search_uid", "").strip() if base_search_uid: element = uuidsToObjects(uuids=base_search_uid) if element and ICollection.providedBy(element[0]): collection = element[0] query = parseFormquery(collection, collection.query) elif element: self.context = element[0] return query
def test_path_with_depth_computed(self): data = { 'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': '/foo::2', } parsed = queryparser.parseFormquery(MockSite(), [data, ]) self.assertEqual(parsed, { 'path': { 'query': ['/%s/foo' % MOCK_SITE_ID], 'depth': 2 } })
def _query(self, **kw): query = self.context.getField('query').getRaw(self.context) q = parseFormquery(self.context, query) if kw.get('start') is not None and q.get('start') is not None: if q['start']['range'] == 'max': # There is a filter capping the maximum start time. # If the filter is earlier than the query, replace it. if q['start']['query'] < kw['start']['query']: kw['start'] = q['start'] elif q['start']['range'] == 'min': # There is a filter capping the minimum start time. # Remake the query into a minmax query. if q['start']['query'] > kw['start']['query']: # If you give ZCatalog a minmax query, where min is # larger than max it *should* reasonably return an # empty result. Well. It doesn't... So we handle that # case specially here: return [] kw['start'] = {'query': (q['start']['query'], kw['start']['query']), 'range': 'minmax'} if kw.get('end') is not None and q.get('end') is not None: if q['end']['range'] == 'min': # There is a filter capping the minimum start time. # If the filter is later than the query, replace it. if q['end']['query'] > kw['end']['query']: kw['end'] = q['end'] elif q['end']['range'] == 'max': # There is a filter capping the minimum start time. # Remake the query into a minmax query: if kw['end']['query'] > q['end']['query']: # If you give ZCatalog a minmax query, where min is # larger than max it *should* reasonably return an # empty result. Well. It doesn't... So we handle that # case specially here: return [] kw['end'] = {'query': (kw['end']['query'], q['end']['query']), 'range': 'minmax'} q.update(kw) #if kw['end'] < kw['start']: ## The end is before the start: The query should have an empty ## result, but unfortunately, portal_catalog isn't very smart ## about this, and will return stuff that has the end well after ## the end, for some reason. So we special case here: #return [] catalog = cmfutils.getToolByName(self.context, 'portal_catalog') return catalog(**q)
def __call__(self, context, query=None): parsed = {} if query: parsed = queryparser.parseFormquery(context, query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) try: catalog = getToolByName(context, 'portal_catalog') except AttributeError: catalog = getToolByName(getSite(), 'portal_catalog') brains = catalog(**parsed) return CatalogVocabulary.fromItems(brains, context)
def events(self, ret_mode=RET_MODE_ACCESSORS, expand=True, batch=True): res = [] if self.is_collection: ctx = self.default_context # Whatever sorting is defined, we're overriding it. sort_on = 'start' sort_order = None if self.mode in ('past', 'all'): sort_order = 'reverse' query = queryparser.parseFormquery( ctx, ctx.query, sort_on=sort_on, sort_order=sort_order) custom_query = self.request.get('contentFilter', {}) if 'start' not in query or 'end' not in query: # ... else don't show the navigation bar start, end = self._start_end start, end = _prepare_range(ctx, start, end) custom_query.update(start_end_query(start, end)) # BAM ... inject our filter viewlet values fc_adapter = ICollectionFilter(ctx) res = fc_adapter.filtered_result(pquery=query, batch=False, custom_query=custom_query) if res is None: # ORIGINAL res = ctx.results(batch=False, brains=True, custom_query=custom_query) if expand: # get start and end values from the query to ensure limited # listing for occurrences _filter_start = self.request.get('_filter_start') if _filter_start: # check for pickadate day filtering fs = DateTime(_filter_start).earliestTime() fe = DateTime(_filter_start).latestTime() start, end = self._expand_events_start_end( dict(query=[fs, fe], range='minmax'), None) else: start, end = self._expand_events_start_end( query.get('start') or custom_query.get('start'), query.get('end') or custom_query.get('end')) res = expand_events( res, ret_mode, start=start, end=end, sort=sort_on, sort_reverse=True if sort_order else False) else: res = self._get_events(ret_mode, expand=expand) if batch: b_start = self.b_start b_size = self.b_size res = Batch(res, size=b_size, start=b_start, orphan=self.orphan) return res
def _render_cachekey(fun, self): context = aq_inner(self.context) if not self.updated: self.update() if self.calendar.getUseSession(): raise ram.DontCache() else: portal_state = getMultiAdapter((context, self.request), name=u'plone_portal_state') key = StringIO() print >> key, [k.encode('utf-8') for k in self.data.kw] print >> key, self.data.review_state print >> key, self.data.name print >> key, portal_state.navigation_root_url() print >> key, cache.get_language(context, self.request) print >> key, self.calendar.getFirstWeekDay() year, month = self.getYearAndMonthToDisplay() print >> key, year print >> key, month navigation_root_path = self.root() start = DateTime('%s/%s/1' % (year, month)) end = DateTime('%s/%s/1 23:59:59' % self.getNextMonth(year, month)) - 1 catalog = getToolByName(context, 'portal_catalog') self.options = {} if navigation_root_path: root_content = self.context.restrictedTraverse( navigation_root_path) if IATTopic.providedBy(root_content): self.options = root_content.buildQuery() elif ICollection.providedBy(root_content): self.options = parseFormquery( root_content, root_content.getField('query').getRaw(root_content)) print >> key, root_content.modified() self.options['start'] = {'query': end, 'range': 'max'} self.options['end'] = {'query': start, 'range': 'min'} _define_search_options(self, self.options) brains = catalog(**self.options) for brain in brains: add_cachekey(key, brain) return key.getvalue()
def parsed_query(self, ): query = _parseJSON(self.request.get('query', '')) if isinstance(query, six.string_types): query = {'SearchableText': {'query': query}} elif query: parsed = queryparser.parseFormquery(self.get_context(), query['criteria']) if 'sort_on' in query: parsed['sort_on'] = query['sort_on'] if 'sort_order' in query: parsed['sort_order'] = str(query['sort_order']) query = parsed else: query = {} return query
def parseQueryString(context, query): parsedquery = queryparser.parseFormquery(context, query) 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 return parsedquery
def get_objects_to_correct(self): if HAS_SOLR: # with solr, its possible to query on Language attribute query = {'Language': {'not': ['fr', 'any']}, } else: catalog_query = [ { "i": "meta_type", "o": "plone.app.querystring.operation.selection.is", "v": ["Meeting", "MeetingItem"], }, ] query = queryparser.parseFormquery(self.portal, catalog_query) res = self.portal.portal_catalog(**query) return res
def test_multi_path(self): data_1 = { 'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': '/foo', } data_2 = { 'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': '/bar', } parsed = queryparser.parseFormquery(MockSite(), [data_1, data_2]) self.assertEqual( parsed, {'path': {'query': [ '/%s/foo' % MOCK_SITE_ID, '/%s/bar' % MOCK_SITE_ID]}})
def getEventsForCalendar(self): navigation_root_path = self.root() self.options = {} if navigation_root_path: root_content = self.rootTopic() if root_content: if IATTopic.providedBy(root_content): self.options = root_content.buildQuery() elif ICollection.providedBy(root_content): self.options = parseFormquery( root_content, root_content.getField('query').getRaw(root_content)) _define_search_options(self, self.options) weeks = self._get_calendar_structure() return weeks
def generate_query_for_events(self): data = json_body(self.request) parsed_query = queryparser.parseFormquery(context=self.context, formquery=data["query"]) fullobjects = data.get("fullobjects", False) b_size = data.get("b_size", None) b_start = data.get("b_start", 0) query = { k: v for k, v in parsed_query.items() if k not in ["start", "end"] } limit = int(data.get("limit", 1000)) sort = "start" sort_reverse = False start = None end = None query_start = parsed_query.get("start", {}) query_end = parsed_query.get("end", {}) if (query_start and isinstance(query_start.get("query", None), list) # noqa and query_start.get("range", "") == "minmax" # noqa and not query_end # noqa ): # caso limite che non deve succedere start = self.get_datetime_value(query_start["query"][0]) end = self.get_datetime_value(query_start["query"][1]) else: if query_start: start = self.get_datetime_value(query_start["query"]) if query_end: end = self.get_datetime_value(query_end["query"]) if data.get("sort_on", ""): sort = data["sort_on"] if data.get("sort_order", ""): sort_reverse = data["sort_order"] == "descending" and True or False return ( start, end, fullobjects, b_size, b_start, query, sort_reverse, sort, limit, )
def object_already_exists(self, obj_id, portal_type): catalog_query = [ { "i": "portal_type", "o": "plone.app.querystring.operation.selection.is", "v": portal_type, }, { "i": "id", "o": "plone.app.querystring.operation.selection.is", "v": obj_id, }, ] query = queryparser.parseFormquery(self.portal, catalog_query) res = self.portal.portal_catalog(**query) if res: logger.info("Already created {object}".format(object=obj_id)) return res
def test_ATPathCriterion(self): crit = self.add_criterion( 'path', 'ATPathCriterion', self.portal.folder.UID()) crit.setRecurse(True) applyProfile(self.portal, 'plone.app.contenttypes:default') self.run_migration() self.assertEqual(self.portal.topic.query, [{'i': 'path', 'o': 'plone.app.querystring.operation.string.path', 'v': self.portal.folder.UID()}]) # check is the query is correct self.assertEqual( parseFormquery(self.portal, self.portal.topic.query), {'path': {'query': ['/plone/folder']}}) # Check that the resulting query does not give an error. self.portal.topic.results
def getResults(self, content, with_sticky=True): """Content is a Collection""" # Make a copy of the query to avoid modifying it query = list(content.query) index_view_keywords = getattr(content, "index_view_keywords", False) # set query for homepage if index_view_keywords: homepage_keywords = content.index_view_keywords query.append({ "i": "hiddenTags", "o": "plone.app.querystring.operation.selection.is", "v": homepage_keywords, }) sort_on = getattr(content, "sort_on", None) sort_order = ("reverse" if getattr(content, "sort_reversed", False) else "ascending") # noqa sort_reversed = getattr(content, "sort_reversed", False) parsedquery = queryparser.parseFormquery(content, query, sort_on, sort_order) portal_catalog = api.portal.get_tool("portal_catalog") brains = portal_catalog(parsedquery) item_count_homepage = getattr(content, "item_count_homepage", 8) if self.is_event_collection(brains): start = DateTime() sort_on = getattr(content, "sort_on", "start") if sort_on in ("start", "end"): filter_and_resort_brains = filter_and_resort( content, brains, start, None, sort_on, sort_reversed) brains = filter_and_resort_brains[:item_count_homepage] brains = brains[:item_count_homepage] if not with_sticky: return brains portal_catalog = api.portal.get_tool(name="portal_catalog") results = {"sticky-results": [], "standard-results": []} for brain in brains: if portal_catalog.getIndexDataForRID(brain.getRID())["is_sticky"]: results["sticky-results"].append(brain) else: results["standard-results"].append(brain) if not results["sticky-results"] and not results["standard-results"]: return None return results
def events(self, ret_mode=RET_MODE_ACCESSORS, expand=False, batch=True): res = [] if self.is_collection: ctx = self.default_context # Whatever sorting is defined, we're overriding it. sort_on = 'start' sort_order = None if self.mode in ('past', 'all'): sort_order = 'reverse' query = queryparser.parseFormquery(ctx, ctx.query, sort_on=sort_on, sort_order=sort_order) custom_query = self.request.get('contentFilter', {}) if 'start' not in query or 'end' not in query: # ... else don't show the navigation bar start, end = self._start_end start, end = _prepare_range(ctx, start, end) custom_query.update(start_end_query(start, end)) res = ctx.results(batch=False, brains=True, custom_query=custom_query) if expand: # get start and end values from the query to ensure limited # listing for occurrences start, end = self._expand_events_start_end( query.get('start') or custom_query.get('start'), query.get('end') or custom_query.get('end')) # import pdb; pdb.set_trace() res = expand_events(res, ret_mode, start=start, end=end, sort=sort_on, sort_reverse=True if sort_order else False) else: res = self._get_events(ret_mode, expand=expand) if batch: b_start = self.b_start b_size = self.b_size res = Batch(res, size=b_size, start=b_start, orphan=self.orphan) return res
def getImageInformation(self): limit = self.context.limit query = queryparser.parseFormquery(self.context, self.context.query) if ILeadImage: query.update({ 'object_provides': { 'query': [IImage.__identifier__, ILeadImage.__identifier__], 'operator': 'or' } }) else: query.update({'object_provides': IImage.__identifier__}) query['sort_limit'] = limit query = self.fix_query(query) catalog = getToolByName(self.context, 'portal_catalog') images = catalog(query) images = images[:limit] return map(self.assemble_image_information, images)