def search(self, *args, **kwargs):
if self.objectImplements:
dict_query = { "objectImplements" : self.objectImplements }
current_query = kwargs.get("query")
if not current_query:
kwargs["query"] = dict_query
else:
if isinstance(current_query, dict):
values = current_query.get("objectImplements", [])
if isinstance(values, basestring):
values = [ values ]
for value in self.objectImplements:
if value not in values:
values.append(value)
kwargs["query"]["objectImplements"] = values
else:
# it is advanced query
advanced_query = [ Eq("objectImplements", value) for value in self.objectImplements ]
if len(advanced_query) > 1:
advanced_query = And(*advanced_query)
else:
advanced_query = advanced_query[0]
kwargs["query"] = And(current_query, advanced_query)
if self.fields:
current_fields = kwargs.get("fields")
if not current_fields:
kwargs["fields"] = self.fields
else:
if isinstance(current_fields, basestring):
current_fields = [ current_fields ]
current_fields.extend(self.fields)
kwargs["fields"] = current_fields
return self.model_catalog(*args, **kwargs)
def get_uids(index_client, root="", types=()):
start = 0
need_results = True
query = [Eq("tx_state", 0)]
if root:
root = root.rstrip('/')
query.append(
Or(Eq("uid", "{}".format(root)),
MatchGlob("uid", "{}/*".format(root))))
if not isinstance(types, (tuple, list)):
types = (types, )
if types:
query.append(In("objectImplements", [dottedname(t) for t in types]))
while need_results:
search_results = index_client.search(
SearchParams(query=And(*query),
start=start,
limit=MODEL_INDEX_BATCH_SIZE,
order_by="uid",
fields=["uid"]))
start += MODEL_INDEX_BATCH_SIZE
for result in search_results.results:
yield result.uid
need_results = start < search_results.total_count
def _typecatComponentBrains(self,
uid=None,
types=(),
meta_type=(),
start=0,
limit=None,
sort='name',
dir='ASC',
name=None,
keys=()):
obj = self._getObject(uid)
spec = get_component_field_spec(meta_type)
if spec is None:
return None, 0
typecat = spec.get_catalog(obj, meta_type)
sortspec = ()
if sort:
if sort not in typecat._catalog.indexes:
# Fall back to slow queries and sorting
return None, 0
sortspec = ((sort, dir), )
querySet = [Generic('path', uid)]
if name:
querySet.append(
Or(*(MatchGlob(field, '*%s*' % name)
for field in spec.fields)))
brains = typecat.evalAdvancedQuery(And(*querySet), sortspec)
total = len(brains)
if limit is None:
brains = brains[start:]
else:
brains = brains[start:start + limit]
return brains, total
def filteredDevices(context, args, *types):
path = '/zport/dmd'
deviceFilter = args.get('deviceFilter', '') or ''
deviceClass = args.get('deviceClass', '') or ''
extraquery = args.get('extraquery', '')
filter = []
if deviceFilter:
filter.append(
MatchGlob('name', '*%s*' % deviceFilter)
| MatchGlob('id', '*%s*' % deviceFilter))
if deviceClass:
organizer = (''.join([path, deviceClass]), )
else:
organizer = (''.join(
[path, args.get('organizer', '/Devices') or '/Devices']), )
if not types:
types = 'Products.ZenModel.Device.Device'
if extraquery:
filter.extend(extraquery)
query = And(*filter) if filter else None
results = IModelCatalogTool(context).search(types,
paths=organizer,
query=query)
for brain in results:
try:
yield brain.getObject()
except Exception:
log.warn("Unable to unbrain at path %s", brain.getPath())
def searchForMembers(self, REQUEST=None, **kw):
"""Search for users (not groups, not groups-as-users) of a site """
if REQUEST:
dict = REQUEST
else:
dict = kw
name = dict.get('name', '')
# Split up search terms but leave quoted ones together
try:
names = shlex.split(name)
except ValueError:
try:
names = shlex.split(name.replace("'", "\\'"))
except ValueError:
names = shlex.split(name.replace("'", "\\'") + '"')
# Short circuit: if all that was asked for was '*', just return everyone
if names == ['*']:
query = And()
else:
queries = []
for name in names:
queries.extend([
MatchGlob('fullname', name),
MatchGlob('email', name),
Eq('getUserName', name)
])
query = Or(*queries)
zLOG.LOG('MembershipTool', zLOG.BLATHER, 'Querying: %s' % query)
catalog = getToolByName(self, 'member_catalog')
return catalog.evalAdvancedQuery(query, ('surname', 'firstname'))
def _buildQuery(self, types, paths, depth, query, filterPermissions):
qs = []
if query is not None:
qs.append(query)
# Build the path query
if not paths:
paths = ('/'.join(self.context.getPhysicalPath()), )
q = {'query': paths}
if depth is not None:
q['depth'] = depth
pathq = Generic('path', q)
qs.append(pathq)
# Build the type query
if not isinstance(types, (tuple, list)):
types = (types, )
subqs = [Eq('objectImplements', dottedname(t)) for t in types]
if subqs:
# Don't unnecessarily nest in an Or if there is only one type query
typeq = subqs[0] if len(subqs) == 1 else Or(*subqs)
qs.append(typeq)
# filter based on permissions
if filterPermissions:
qs.append(
In('allowedRolesAndUsers',
allowedRolesAndGroups(self.context)))
# Consolidate into one query
return And(*qs)
def _serviceSearch(self,
limit=None,
start=None,
sort='name',
dir='ASC',
params=None,
uid=None,
criteria=()):
cat = ICatalogTool(self._getObject(uid))
reverse = dir == 'DESC'
qs = []
query = None
if params:
if 'name' in params:
qs.append(MatchRegexp('name', '(?i).*%s.*' % params['name']))
if 'port' in params:
qs.append(MatchRegexp('port', '(?i).*%s.*' % params['port']))
if qs:
query = And(*qs)
return cat.search("Products.ZenModel.ServiceClass.ServiceClass",
start=start,
limit=limit,
orderby=sort,
reverse=reverse,
query=query)
def _processSearch(self,
limit=None,
start=None,
sort='name',
dir='ASC',
params=None,
uid=None,
criteria=()):
ob = self._getObject(uid) if isinstance(uid, basestring) else uid
cat = ICatalogTool(ob)
reverse = dir == 'DESC'
qs = []
query = None
if params:
if 'name' in params:
qs.append(MatchRegexp('name', '(?i).*%s.*' % params['name']))
if qs:
query = And(*qs)
return cat.search("Products.ZenModel.OSProcessClass.OSProcessClass",
start=start,
limit=limit,
orderby=sort,
reverse=reverse,
query=query)
def getDeviceBrains(self, uid=None, start=0, limit=50, sort='name',
dir='ASC', params=None, hashcheck=None):
cat = ICatalogTool(self._getObject(uid))
reverse = dir=='DESC'
qs = []
query = None
globFilters = {}
if params is None:
params = {}
for key, value in params.iteritems():
if key == 'ipAddress':
ip = ensureIp(value)
try:
checkip(ip)
except IpAddressError:
pass
else:
if numbip(ip):
minip, maxip = getSubnetBounds(ip)
qs.append(Between('ipAddress', str(minip), str(maxip)))
elif key == 'deviceClass':
qs.append(MatchRegexp('uid', '(?i).*%s.*' %
value))
elif key == 'productionState':
qs.append(Or(*[Eq('productionState', str(state))
for state in value]))
else:
globFilters[key] = value
if qs:
query = And(*qs)
brains = cat.search('Products.ZenModel.Device.Device', start=start,
limit=limit, orderby=sort, reverse=reverse,
query=query, globFilters=globFilters, hashcheck=hashcheck)
return brains
def _get_device_components(self, device, str_types, *args, **kwargs):
types = set(["Products.ZenModel.DeviceComponent.DeviceComponent"])
if str_types:
types = types | set(str_types)
query = [ Eq("objectImplements", str_type) for str_type in types ]
query.append(Eq("deviceId", "/".join(device.getPrimaryPath())))
kwargs["query"] = And(*query)
return self.model_catalog.search(*args, **kwargs)
def _componentSearch(self, uid=None, types=(), meta_type=(), start=0,
limit=None, sort='name', dir='ASC', name=None, keys=()):
reverse = dir=='DESC'
if isinstance(types, basestring):
types = (types,)
if isinstance(meta_type, basestring):
meta_type = (meta_type,)
querySet = []
if meta_type:
querySet.append(Or(*(Eq('meta_type', t) for t in meta_type)))
querySet.append(Generic('getAllPaths', uid))
query = And(*querySet)
obj = self._getObject(uid)
cat = obj.device().componentSearch
if 'getAllPaths' not in cat.indexes():
obj.device()._createComponentSearchPathIndex()
brains = cat.evalAdvancedQuery(query)
# unbrain the results
comps=map(IInfo, map(unbrain, brains))
# filter the components
if name is not None:
comps = self._filterComponents(comps, keys, name)
total = len(comps)
hash_ = str(total)
def componentSortKey(parent):
val = getattr(parent, sort)
if val:
if isinstance(val, list):
val = val[0]
if callable(val):
val = val()
if IInfo.providedBy(val):
val = val.name
return val
# sort the components
sortedResults = list(sorted(comps, key=componentSortKey, reverse=reverse))
# limit the search results to the specified range
if limit is None:
pagedResult = sortedResults[start:]
else:
pagedResult = sortedResults[start:start + limit]
# fetch any rrd data necessary
self.bulkLoadMetricData(pagedResult)
return SearchResults(iter(pagedResult), total, hash_, False)
def findDeviceByIdExact(self, devicename):
"""
Look up device in catalog and return it. devicename
must match device id exactly
"""
if devicename:
query = And( Eq("objectImplements", "Products.ZenModel.Device.Device"), Eq('id', devicename) )
search_results = IModelCatalogTool(self.dmd.Devices).search(query=query)
for brain in search_results.results:
dev = brain.getObject()
if dev.id == devicename:
return dev
def _componentSearch(self,
uid=None,
types=(),
meta_type=(),
start=0,
limit=None,
sort='name',
dir='ASC',
name=None,
keys=()):
reverse = dir == 'DESC'
if isinstance(types, basestring):
types = (types, )
if isinstance(meta_type, basestring):
meta_type = (meta_type, )
querySet = []
if meta_type:
querySet.append(Or(*(Eq('meta_type', t) for t in meta_type)))
querySet.append(Generic('getAllPaths', uid))
query = And(*querySet)
obj = self._getObject(uid)
if getattr(aq_base(obj.device()), 'componentSearch', None) is None:
obj.device()._create_componentSearch()
cat = obj.device().componentSearch
if 'getAllPaths' not in cat.indexes():
obj.device()._createComponentSearchPathIndex()
brains = cat.evalAdvancedQuery(query)
# unbrain the results
comps = map(IInfo, map(unbrain, brains))
total = len(comps)
hash_ = str(total)
# filter the components
if name is not None:
wrapped = map(IInfo, map(unbrain, brains))
comps = self._filterComponents(wrapped, keys, name)
total = len(comps)
hash_ = str(total)
# sort the components
sortedResults = list(
sorted(comps, key=lambda x: getattr(x, sort), reverse=reverse))
# limit the search results to the specified range
if limit is None:
pagedResult = sortedResults[start:]
else:
pagedResult = sortedResults[start:start + limit]
return SearchResults(iter(pagedResult), total, hash_, False)
def getObjectBrains(self,
uid=None,
start=0,
limit=50,
sort='name',
dir='ASC',
params=None,
hashcheck=None,
types=(),
fields=[]):
cat = IModelCatalogTool(self._getObject(uid))
reverse = bool(dir == 'DESC')
qs = []
query = None
globFilters = {}
prodStates = None
params = params if params else {}
for key, value in params.iteritems():
if key == 'ipAddress':
qs.append(MatchGlob('text_ipAddress', '{}*'.format(value)))
elif key == 'productionState':
qs.append(
Or(*[Eq('productionState', str(state))
for state in value]))
# ZEN-30949 - stringify values from the 'priority' list if it's passed in for query criteria
elif key == 'priority':
qs.append(
Or(*[Eq('priority', str(priority)) for priority in value]))
# ZEN-10057 - move filtering on indexed groups/systems/location from post-filter to query
elif key in organizersToClass:
organizerQuery = self.findMatchingOrganizers(
organizersToClass[key], organizersToPath[key], value)
if not organizerQuery:
return []
qs.append(organizerQuery)
else:
globFilters[key] = value
if qs:
query = And(*qs)
return cat.search(types,
start=start,
limit=limit,
orderby=sort,
reverse=reverse,
query=query,
globFilters=globFilters,
hashcheck=hashcheck,
fields=fields)
def _get_component_types_from_model_catalog(self, uid):
""" """
componentTypes = {}
uuidMap = {}
model_catalog = IModelCatalogTool(self.context.dmd)
model_query = Eq('objectImplements', "Products.ZenModel.DeviceComponent.DeviceComponent")
model_query = And(model_query, Eq("deviceId", uid))
model_query_results = model_catalog.search(query=model_query, fields=["uuid", "meta_type"])
for brain in model_query_results.results:
uuidMap[brain.uuid] = brain.meta_type
compType = componentTypes.setdefault(brain.meta_type, { 'count' : 0, 'severity' : 0 })
compType['count'] += 1
return (componentTypes, uuidMap)
def transform_query(self, query):
search_indexes = []
other_indexes = []
search_keys = ('customer', 'Subject', 'No matches by customer')
for key in query.keys():
if key in ('b_start', 'b_size', 'batch', 'show_inactive'):
continue
if key in search_keys:
if key == 'customer' and query['customer'] == 'All':
for customer in self.customers_list():
if customer in ('All', 'No matches by customer'):
continue
search_indexes.append(Eq('customer', customer))
elif (key == 'customer' and
query['customer'] == 'No matches by customer'):
pass
else:
self.add_to_index_list(search_indexes, query, key)
else:
self.add_to_index_list(other_indexes, query, key)
other_indexes = And(*other_indexes)
search_indexes = Or(*search_indexes)
return And(other_indexes, search_indexes)
def _add_tx_state_query(self, search_params, tx_state):
"""
only interested in docs indexed by committed transactions or
in docs temporary committed by the current transaction
"""
values = [0] # default tx_state for committed transactions
if tx_state:
values.append(tx_state.tid)
if isinstance(search_params.query, dict):
search_params.query[TX_STATE_FIELD] = values
else: # We assume it is an AdvancedQuery
or_query = [Eq(TX_STATE_FIELD, value) for value in values]
search_params.query = And(search_params.query, Or(*or_query))
return search_params
def getSubComponents(self):
cat = ICatalogTool(self)
query = And(
Not(
Eq('objectImplements',
'Products.ZenModel.ComponentGroup.ComponentGroup')),
Not(Eq('objectImplements', 'Products.ZenModel.Device.Device')))
brains = cat.search(query=query)
children = []
for brain in brains:
try:
children.append(brain.getObject())
except:
pass
return children
def _findDevice(self, devicename, useTitle=True, commit_dirty=False):
"""
Returns all devices whose ip/id/title match devicename.
ip/id matches are at the front of the list.
@rtype: list of brains
"""
ors = [ MatchGlob('id', devicename), MatchGlob('text_ipAddress', devicename) ]
if useTitle:
ors.append(MatchGlob('name', devicename))
query = And( Eq("objectImplements", "Products.ZenModel.Device.Device"), Or(*ors) )
fields = [ "name", "id", "text_ipAddress" ]
search_results = IModelCatalogTool(self.dmd.Devices).search(query=query, fields=fields, commit_dirty=commit_dirty)
return list(search_results.results)
def keyword_search(obj, keyword, types=(), meta_type=None):
"""Generate objects with a matching serial number."""
keyword_query = Eq('searchKeywords', keyword)
query = None
if meta_type:
query = And(Eq('meta_type', meta_type), keyword_query)
else:
query = keyword_query
for brain in ICatalogTool(obj.dmd).search(types, query=query):
try:
yield brain.getObject()
except Exception:
# ignore a stale entry
pass
def get_possible_faqs(self):
log.info('get_possible_faqs')
queries = []
title = In('Title', ["*frequently*", "*faq*", "FAQ*", "Frequently*"])
portal_type = In("portal_type", ["Document", "RichDocument", "Folder"])
ids = ["faq", "faq.php", "faq.stm", "faqs"]
for i in range(0, 10):
ids.append('faq%d.stm' % i)
ids.append('faq0%d.php' % i)
id = In('getId', ids)
body = Eq('SearchableText', "FAQ")
fop = Eq('path', '/osha/portal/fop')
advanced_query = And(Or(id, title, body), portal_type, Not(fop))
ls = self.portal_catalog.evalAdvancedQuery(advanced_query,
(('Date', 'desc'), ))
# XXX: Didn't work :(
# ls = self.portal_catalog(
# getId='faq.php',
# path='/osha/portal/en/good_practice/priority_groups/disability/')
ls = self.portal_catalog(
getId='faq2.stm',
path='osha/en/good_practice/topics/dangerous_substances/faq2.stm')
# ls = self.portal_catalog(
# getId='faq.php',
# path='osha/en/good_practice/topics/accident_prevention/')
log.info("Processing FAQs: %s" % "\n".join([i.getURL() for i in ls]))
odict = {}
for l in ls:
o = l.getObject()
odict[o.absolute_url()] = o
ts = o.getTranslations().values()
for t in ts:
odict[t[0].absolute_url()] = t[0]
objects = odict.values()
return objects
k = ['/'.join(o.getPhysicalPath()) for o in objects]
k.sort()
display_str = '\n'.join(k) or 'none'
return display_str
def getDevProdStateJSON(self, prodStates=['Maintenance']):
"""
Return a map of device to production state in a format suitable for a
YUI data table.
@return: A JSON representation of a dictionary describing devices
@rtype: "{
'columns':['Device', 'Prod State'],
'data':[
{'Device':'<a href=/>', 'Prod State':'Production'},
{'Device':'<a href=/>', 'Prod State':'Maintenance'},
]}"
"""
if isinstance(prodStates, basestring):
prodStates = [prodStates]
def getProdStateInt(prodStateString):
for t in self.context.getProdStateConversions():
if t[0] == prodStateString:
return t[1]
numericProdStates = [getProdStateInt(p) for p in prodStates]
catalog = IModelCatalogTool(self.context.getPhysicalRoot().zport.dmd)
query = In('productionState', numericProdStates)
query = And(query,
Eq('objectImplements', 'Products.ZenModel.Device.Device'))
objects = list(catalog.search(query=query, orderby='id',
fields="uuid"))
devs = (x.getObject() for x in objects)
mydict = {'columns': ['Device', 'Prod State'], 'data': []}
for dev in devs:
if not self.context.checkRemotePerm(ZEN_VIEW, dev): continue
mydict['data'].append({
'Device': dev.getPrettyLink(),
'Prod State': dev.getProdState()
})
if len(mydict['data']) >= 100:
break
return mydict
def getDeviceByIpAddress(self, deviceName, collector="localhost", ipAddress=""):
# convert device name to an ip address
if not ipAddress:
if isip(deviceName):
ipAddress = deviceName
else:
try:
ipAddress = getHostByName(deviceName)
except socket.error:
# look for duplicate name
return self.context.Devices.findDeviceByIdExact(deviceName)
# find a device with the same ip on the same collector
cat = IModelCatalogTool(self.context.Devices)
query = And(Eq('text_ipAddress', ipAddress),
Eq('objectImplements', 'Products.ZenModel.Device.Device'))
search_results = cat.search(query=query)
for brain in search_results.results:
if brain.getObject().getPerformanceServerName() == collector:
return brain.getObject()
def getSubComponents(self, meta_type="", monitored=True):
"""
Return generator of components, by meta_type if specified
"""
catalog = IModelCatalogTool(self)
COMPONENT = 'Products.ZenModel.DeviceComponent.DeviceComponent'
monitorq, typeq = None, None
if monitored:
monitorq = Eq('monitored', '1')
if meta_type:
typeq = Eq('meta_type', meta_type)
queries = filter(None, (monitorq, typeq))
if queries:
query = And(*queries) if len(queries) > 1 else queries[0]
else:
query = None
for brain in catalog.search(COMPONENT, query=query):
try:
yield brain.getObject()
except KeyError:
log.warn("bad path '%s' in global catalog", brain.getPath())
def getDeviceBrains(self, uid=None, start=0, limit=50, sort='name',
dir='ASC', params=None, hashcheck=None):
cat = ICatalogTool(self._getObject(uid))
reverse = bool(dir == 'DESC')
qs = []
query = None
globFilters = {}
if params is None:
params = {}
for key, value in params.iteritems():
if key == 'ipAddress':
ip = ensureIp(value)
try:
checkip(ip)
except IpAddressError:
pass
else:
if numbip(ip):
minip, maxip = getSubnetBounds(ip)
qs.append(Between('ipAddress', str(minip), str(maxip)))
# ZEN-10057 - move filtering on indexed groups/systems/location from post-filter to query
elif key in organizersToClass:
organizerQuery = self.findMatchingOrganizers(organizersToClass[key], organizersToPath[key], value)
if not organizerQuery:
return []
qs.append(organizerQuery)
elif key == 'productionState':
qs.append(Or(*[Eq('productionState', str(state))
for state in value]))
else:
globFilters[key] = value
if qs:
query = And(*qs)
brains = cat.search(
'Products.ZenModel.Device.Device', start=start,
limit=limit, orderby=sort, reverse=reverse,
query=query, globFilters=globFilters, hashcheck=hashcheck
)
return brains
def _parse_user_query(self, query):
"""
# if query is a dict, we convert it to AdvancedQuery
# @TODO We should make the default query something other than AdvancedQuery
"""
def _parse_basic_query(attr, value):
if isinstance(value, str) and '*' in value:
return MatchGlob(attr, value)
else:
return Eq(attr, value)
if isinstance(query, dict):
subqueries = []
for attr, value in query.iteritems():
if isinstance(value, (list, set, tuple)):
# If value is a list or similar, we build an OR
or_queries = []
for or_query in value:
or_queries.append(_parse_basic_query(attr, or_query))
subqueries.append(Or(*or_queries))
else:
subqueries.append(_parse_basic_query(attr, value))
query = And(*subqueries)
return query
def search_mac(self, mac_address):
queries = []
queries.append(Eq("objectImplements", "Products.ZenModel.IpInterface.IpInterface"))
queries.append(Eq("macaddress", mac_address))
return self.model_catalog.search(query=And(*queries))
def get_rrd_templates(self, *args, **kwargs):
query = Eq("objectImplements", "Products.ZenModel.RRDTemplate.RRDTemplate")
kwargs["query"] = And(query, MatchGlob('uid', "/zport/dmd/Devices*"))
return self.model_catalog.search(*args, **kwargs)
def folderitems(self, full_objects = False):
"""
>>> portal = layer['portal']
>>> portal_url = portal.absolute_url()
>>> from plone.app.testing import SITE_OWNER_NAME
>>> from plone.app.testing import SITE_OWNER_PASSWORD
Test page batching https://github.com/bikalabs/Bika-LIMS/issues/1276
When visiting the second page, the Water sampletype should be displayed:
>>> browser = layer['getBrowser'](portal, loggedIn=True, username=SITE_OWNER_NAME, password=SITE_OWNER_PASSWORD)
>>> browser.open(portal_url+"/bika_setup/bika_sampletypes/folder_view?",
... "list_pagesize=10&list_review_state=default&list_pagenumber=2")
>>> browser.contents
'...Water...'
"""
#self.contentsMethod = self.context.getFolderContents
if not hasattr(self, 'contentsMethod'):
self.contentsMethod = getToolByName(self.context, self.catalog)
context = aq_inner(self.context)
plone_layout = getMultiAdapter((context, self.request), name = u'plone_layout')
plone_utils = getToolByName(context, 'plone_utils')
plone_view = getMultiAdapter((context, self.request), name = u'plone')
portal_properties = getToolByName(context, 'portal_properties')
portal_types = getToolByName(context, 'portal_types')
workflow = getToolByName(context, 'portal_workflow')
site_properties = portal_properties.site_properties
norm = getUtility(IIDNormalizer).normalize
if self.request.get('show_all', '').lower() == 'true' \
or self.show_all == True \
or self.pagesize == 0:
show_all = True
else:
show_all = False
pagenumber = int(self.request.get('pagenumber', 1) or 1)
pagesize = self.pagesize
start = (pagenumber - 1) * pagesize
end = start + pagesize - 1
if (hasattr(self, 'And') and self.And) \
or (hasattr(self, 'Or') and self.Or):
# if contentsMethod is capable, we do an AdvancedQuery.
if hasattr(self.contentsMethod, 'makeAdvancedQuery'):
aq = self.contentsMethod.makeAdvancedQuery(self.contentFilter)
if hasattr(self, 'And') and self.And:
tmpAnd = And()
for q in self.And:
tmpAnd.addSubquery(q)
aq &= tmpAnd
if hasattr(self, 'Or') and self.Or:
tmpOr = Or()
for q in self.Or:
tmpOr.addSubquery(q)
aq &= tmpOr
brains = self.contentsMethod.evalAdvancedQuery(aq)
else:
# otherwise, self.contentsMethod must handle contentFilter
brains = self.contentsMethod(self.contentFilter)
else:
brains = self.contentsMethod(self.contentFilter)
results = []
self.page_start_index = 0
current_index = -1
for i, obj in enumerate(brains):
# we don't know yet if it's a brain or an object
path = hasattr(obj, 'getPath') and obj.getPath() or \
"/".join(obj.getPhysicalPath())
if hasattr(obj, 'getObject'):
obj = obj.getObject()
# check if the item must be rendered or not (prevents from
# doing it later in folderitems) and dealing with paging
if not self.isItemAllowed(obj):
continue
# avoid creating unnecessary info for items outside the current
# batch; only the path is needed for the "select all" case...
# we only take allowed items into account
current_index += 1
if not show_all and not (start <= current_index <= end):
results.append(dict(path = path, uid = obj.UID()))
continue
uid = obj.UID()
title = obj.Title()
description = obj.Description()
icon = plone_layout.getIcon(obj)
url = obj.absolute_url()
relative_url = obj.absolute_url(relative = True)
fti = portal_types.get(obj.portal_type)
if fti is not None:
type_title_msgid = fti.Title()
else:
type_title_msgid = obj.portal_type
url_href_title = '%s at %s: %s' % (
t(type_title_msgid),
path,
to_utf8(description))
modified = self.ulocalized_time(obj.modified()),
# element css classes
type_class = 'contenttype-' + \
plone_utils.normalizeString(obj.portal_type)
state_class = ''
states = {}
for w in workflow.getWorkflowsFor(obj):
state = w._getWorkflowStateOf(obj).id
states[w.state_var] = state
state_class += "state-%s " % state
results_dict = dict(
obj = obj,
id = obj.getId(),
title = title,
uid = uid,
path = path,
url = url,
fti = fti,
item_data = json.dumps([]),
url_href_title = url_href_title,
obj_type = obj.Type,
size = obj.getObjSize,
modified = modified,
icon = icon.html_tag(),
type_class = type_class,
# a list of lookups for single-value-select fields
choices = {},
state_class = state_class,
relative_url = relative_url,
view_url = url,
table_row_class = "",
category = 'None',
# a list of names of fields that may be edited on this item
allow_edit = [],
# a list of names of fields that are compulsory (if editable)
required = [],
# "before", "after" and replace: dictionary (key is column ID)
# A snippet of HTML which will be rendered
# before/after/instead of the table cell content.
before = {}, # { before : "<a href=..>" }
after = {},
replace = {},
)
try:
self.review_state = workflow.getInfoFor(obj, 'review_state')
state_title = workflow.getTitleForStateOnType(
self.review_state, obj.portal_type)
state_title = t(PMF(state_title))
except:
self.review_state = 'active'
state_title = None
if self.review_state:
results_dict['review_state'] = self.review_state
for state_var, state in states.items():
if not state_title:
state_title = workflow.getTitleForStateOnType(
state, obj.portal_type)
results_dict[state_var] = state
results_dict['state_title'] = state_title
# extra classes for individual fields on this item { field_id : "css classes" }
results_dict['class'] = {}
for name, adapter in getAdapters((obj, ), IFieldIcons):
auid = obj.UID() if hasattr(obj, 'UID') and callable(obj.UID) else None
if not auid:
continue
alerts = adapter()
# logger.info(str(alerts))
if alerts and auid in alerts:
if auid in self.field_icons:
self.field_icons[auid].extend(alerts[auid])
else:
self.field_icons[auid] = alerts[auid]
# Search for values for all columns in obj
for key in self.columns.keys():
if hasattr(obj, key):
# if the key is already in the results dict
# then we don't replace it's value
if results_dict.has_key(key):
continue
value = getattr(obj, key)
if callable(value):
value = value()
results_dict[key] = value
results.append(results_dict)
return results
def search(self, request):
"""
"""
# get serchterms
searchable = request.form.get("SearchableText", None)
fulltext = request.form.get("SearchableText", "")
authors = request.form.get("authors", "")
#author_id = request.form.get("author_id", "")
abstract = request.form.get("abstract", "")
title = request.form.get("title", "")
jel = request.form.get("jel", "")
papers = request.form.get("papers", [])
#year = request.form.get("year", "all")
#period = request.form.get("period", "all")
query = ""
#import pdb; pdb.set_trace()
if "discussion" in papers:
query = Or(
Eq('portal_type', 'File'),
And(Eq('portal_type', "DiscussionPaper"),
In('review_state', ("rejected", "discussible"))))
if "journal" in papers:
query_jp = Or(Eq("portal_type", "JournalPaper"),
Eq('portal_type', 'eJFile'))
if query == "":
query = query_jp
else:
query = Or(query, query_jp)
#if "comment" in papers:
# query = And(Eq('portal_type', "Comment"))
if query == "":
return []
if searchable is not None:
if searchable == "":
return []
query = And(query, Eq("SearchableText", searchable))
# if year != "all":
# year_start, year_end = _createYearRange(year)
# query = And(query,
# Between("created", year_start, year_end))
# elif period != "all":
# period_start, period_end = _createPeriod(period)
# query = And(query,
# Between("created", period_start, period_end))
if fulltext != "":
#query_fulltext = In("eJFulltext", fulltext)
query_fulltext = In("SearchableText", fulltext)
query = And(query, query_fulltext)
#### XXX getAuthorsForTitle nicht mehr existent. refactoren!
if authors != "":
query_author = In("getAuthorsForTitle", authors)
query = And(query, query_author)
if abstract != "":
query_abstract = Eq("getAbstract", abstract)
query = And(query, query_abstract)
if title != "":
query_title = In("Title", title)
query = And(query, query_title)
if jel != "":
query_jel = Eq("getJelAsString", jel)
query = And(query, query_jel)
# search
brains = self.context.portal_catalog.evalAdvancedQuery(query)
return brains
def folderitems(self, full_objects = False):
"""
"""
#self.contentsMethod = self.context.getFolderContents
if not hasattr(self, 'contentsMethod'):
self.contentsMethod = getToolByName(self.context, self.catalog)
context = aq_inner(self.context)
plone_layout = getMultiAdapter((context, self.request), name = u'plone_layout')
plone_utils = getToolByName(context, 'plone_utils')
plone_view = getMultiAdapter((context, self.request), name = u'plone')
portal_properties = getToolByName(context, 'portal_properties')
portal_types = getToolByName(context, 'portal_types')
workflow = getToolByName(context, 'portal_workflow')
site_properties = portal_properties.site_properties
norm = getUtility(IIDNormalizer).normalize
show_all = self.request.get('show_all', '').lower() == 'true'
pagenumber = int(self.request.get('pagenumber', 1) or 1)
pagesize = self.pagesize
start = (pagenumber - 1) * pagesize
end = start + pagesize
if (hasattr(self, 'And') and self.And) \
or (hasattr(self, 'Or') and self.Or):
# if contentsMethod is capable, we do an AdvancedQuery.
if hasattr(self.contentsMethod, 'makeAdvancedQuery'):
aq = self.contentsMethod.makeAdvancedQuery(self.contentFilter)
if hasattr(self, 'And') and self.And:
tmpAnd = And()
for q in self.And:
tmpAnd.addSubquery(q)
aq &= tmpAnd
if hasattr(self, 'Or') and self.Or:
tmpOr = Or()
for q in self.Or:
tmpOr.addSubquery(q)
aq &= tmpOr
brains = self.contentsMethod.evalAdvancedQuery(aq)
else:
# otherwise, self.contentsMethod must handle contentFilter
brains = self.contentsMethod(self.contentFilter)
else:
brains = self.contentsMethod(self.contentFilter)
results = []
self.page_start_index = ""
for i, obj in enumerate(brains):
# we don't know yet if it's a brain or an object
path = hasattr(obj, 'getPath') and obj.getPath() or \
"/".join(obj.getPhysicalPath())
# avoid creating unnecessary info for items outside the current
# batch; only the path is needed for the "select all" case...
if not show_all and not start <= i < end:
if hasattr(obj, 'getObject'):
uid = obj.UID
else:
uid = obj.UID()
results.append(dict(path = path, uid = uid))
continue
if self.page_start_index == "":
self.page_start_index = i
if hasattr(obj, 'getObject'):
obj = obj.getObject()
uid = obj.UID()
title = obj.Title()
description = obj.Description()
icon = plone_layout.getIcon(obj)
url = obj.absolute_url()
relative_url = obj.absolute_url(relative = True)
fti = portal_types.get(obj.portal_type)
if fti is not None:
type_title_msgid = fti.Title()
else:
type_title_msgid = obj.portal_type
url_href_title = u'%s at %s: %s' % \
(self.context.translate(type_title_msgid,
context = self.request),
path,
safe_unicode(description))
modified = self.ulocalized_time(obj.modified()),
# element css classes
type_class = 'contenttype-' + \
plone_utils.normalizeString(obj.portal_type)
state_class = ''
states = {}
for w in workflow.getWorkflowsFor(obj):
state = w._getWorkflowStateOf(obj).id
states[w.state_var] = state
state_class += "state-%s " % state
results_dict = dict(
obj = obj,
id = obj.getId,
title = title,
uid = uid,
path = path,
url = url,
fti = fti,
item_data = json.dumps([]),
url_href_title = url_href_title,
obj_type = obj.Type,
size = obj.getObjSize,
modified = modified,
icon = icon.html_tag(),
type_class = type_class,
# a list of lookups for single-value-select fields
choices = {},
state_class = state_class,
relative_url = relative_url,
view_url = url,
table_row_class = "",
# a list of names of fields that may be edited on this item
allow_edit = [],
# a list of names of fields that are compulsory (if editable)
required = [],
# "before", "after" and replace: dictionary (key is column ID)
# A snippet of HTML which will be rendered
# before/after/instead of the table cell content.
before = {}, # { before : "<a href=..>" }
after = {},
replace = {},
)
try:
review_state = workflow.getInfoFor(obj, 'review_state')
state_title = self.context.translate(
PMF(workflow.getTitleForStateOnType(review_state,
obj.portal_type)))
except:
review_state = 'active'
state_title = None
if review_state:
results_dict['review_state'] = review_state
for state_var, state in states.items():
if not state_title:
state_title = workflow.getTitleForStateOnType(
state, obj.portal_type)
results_dict[state_var] = state
results_dict['state_title'] = state_title
# XXX add some kind of out-of-date indicator to bika listing
## if App.config.getConfiguration().debug_mode:
## from Products.CMFEditions.utilities import dereference
## pr = getToolByName(self.context, 'portal_repository')
## o = hasattr(obj, 'getObject') and obj.getObject() or obj
## if pr.isVersionable(o):
## pa = getToolByName(self.context, 'portal_archivist')
## history_id = str(dereference(o)[1])
## version_id = hasattr(o, 'version_id') \
## and str(o.version_id) or None
## if not 'version_id' in self.columns.keys():
## self.columns['version_id'] = {'title':'version'}
## for x in range(len(self.review_states)):
## self.review_states[x]['columns'].append('version_id')
## results_dict['version_id'] = '%s/%s' % (version_id, history_id)
# extra classes for individual fields on this item { field_id : "css classes" }
results_dict['class'] = {}
# Search for values for all columns in obj
for key in self.columns.keys():
if hasattr(obj, key):
# if the key is already in the results dict
# then we don't replace it's value
if results_dict.has_key(key):
continue
value = getattr(obj, key)
if callable(value):
value = value()
results_dict[key] = value
results.append(results_dict)
return results