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 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 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 __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)
