def getAllDocuments(self, option_json):
response = {"rows": []}
kw = {}
if isinstance(option_json.get('query'), dict):
kw['query'] = self.parseQuery(option_json["query"])
kw['query'] = ComplexQuery(
kw['query'],
ComplexQuery(
operator='or',
*[SimpleQuery(comparison_operator="=", portal_type=x) \
for x in self.allowed_portal_type_list]
),
comparison_operator='and'
)
else:
kw['query'] = ComplexQuery(
operator='or',
*[SimpleQuery(comparison_operator="=", portal_type=x) \
for x in self.allowed_portal_type_list]
)
if isinstance(option_json.get('limit'), list):
kw['limit'] = tuple(option_json['limit'])
c = self.simple_conversion_dict
if isinstance(option_json.get('sort_on'), list):
for i in range(len(option_json['sort_on'])):
s = option_json['sort_on'][i]
option_json['sort_on'][i] = dictGetKeyFromValue(c, s[0], s[0])
kw['sort_on'] = option_json['sort_on']
if not isinstance(option_json.get('select_list'), list):
option_json['select_list'] = []
if option_json['select_list'] != []:
id_list = context.portal_catalog.getSQLCatalog().getColumnIds()
i = len(option_json['select_list']) - 1
while i >= 0:
s = option_json['select_list'][i]
option_json['select_list'][i] = dictGetKeyFromValue(c, s, s)
if option_json['select_list'][i] not in id_list:
option_json['select_list'].pop(i)
i -= 1
kw['select_list'] = option_json['select_list']
#portal.person_module.log("catalog ----------===============>", kw);
for document in context.portal_catalog(**kw):
url = tool.getUrlFromDocument(document)
row = {"id": url, "key": url, "value": {}}
for erp5_meta in option_json['select_list']:
jio_meta = c.get(erp5_meta, erp5_meta)
row['value'][jio_meta] = getattr(document, erp5_meta, None)
if isinstance(row['value'][jio_meta], DateTime):
row['value'][jio_meta] = row['value'][jio_meta].ISO8601()
if option_json.get('include_docs') is True:
row["doc"] = self.getDocumentMetadata({"_id": url})
response["rows"].append(row)
response["total_rows"] = len(response["rows"])
return response
def test_006_testRelatedKey_with_multiple_join(self):
# The name of catalog parameter does not matter at all
# ComplexQuery(ComplexQuery(AutoQuery(RelatedQuery(SimpleQuery())), AutoQuery(RelatedQuery(SimpleQuery()))))
# 'AutoQuery' doesn't need any ReferenceQuery equivalent.
self.catalog(ReferenceQuery(ReferenceQuery(
ReferenceQuery(RelatedReferenceQuery(ReferenceQuery(operator='=', default='a')), operator='and'),
ReferenceQuery(RelatedReferenceQuery(ReferenceQuery(operator='=', default='b')), operator='and')
, operator='and'), operator='and'),
{'query': ComplexQuery(Query(related_default='a'), Query(related_default='b'))})
def _getEffectiveModel(self, start_date, stop_date):
"""Return the most appropriate model using effective_date, expiration_date
and version number.
An effective model is a model which start and stop_date are equal (or
excluded) to the range of the given start and stop_date and with the
higher version number (if there is more than one)
XXX Should we moved this function to a class ? Which one ?
What about reusing IVersionable ?
"""
reference = self.getProperty('reference')
if not reference:
return self
query_list = [
Query(reference=reference),
Query(portal_type=self.getPortalType()),
Query(validation_state=('deleted', 'invalidated'), operator='NOT')
]
if start_date is not None:
query_list.append(
ComplexQuery(Query(effective_date=None),
Query(effective_date=start_date, range='<='),
logical_operator='OR'))
if stop_date is not None:
query_list.append(
ComplexQuery(Query(expiration_date=None),
Query(expiration_date=stop_date, range='>'),
logical_operator='OR'))
# XXX What to do the catalog returns nothing (either because 'self' was just
# created and not yet indexed, or because it was invalidated) ?
# For the moment, we return self if self is invalidated and we raise otherwise.
# This way, if this happens in activity it may succeed when activity is retried.
model_list = self.getPortalObject(
).portal_catalog.unrestrictedSearchResults(
query=ComplexQuery(logical_operator='AND', *query_list),
sort_on=(('version', 'descending'), ))
if not model_list:
if self.getValidationState() == 'invalidated':
return self
raise KeyError('No %s found with the reference %s between %s and %s' % \
(self.getPortalType(), reference, start_date, stop_date))
return model_list[0].getObject()
def rec(query_dict):
if query_dict.get("type") == "simple":
# if query_dict.get("key") not in self.allowed_property_id_list:
# return None
for erp5_key, jio_key in self.simple_conversion_dict.items():
if query_dict["key"] == jio_key:
query_dict["key"] = erp5_key
break
return SimpleQuery(comparison_operator=query_dict['operator'],
**{query_dict['key']: query_dict['value']})
if query_dict.get("type") == "complex":
tool.listMapReplace(rec, query_dict['query_list'])
try:
while True:
query_dict['query_list'].remove(None)
except ValueError:
pass
return ComplexQuery(operator=query_dict['operator'],
*query_dict['query_list'])
return None
node = portal.portal_catalog.getObject(params['node_uid'])
is_pl_account = node.isMemberOf('account_type/expense')\
or node.isMemberOf('account_type/income')
# remove unknown catalog keys from params
params.pop('detailed_from_date_summary', None)
period_start_date = params.pop('period_start_date', None)
if is_pl_account and not from_date:
from_date = period_start_date
if portal.portal_selections.getSelectionParamsFor(selection_name).get(
'hide_grouping'):
if params.get('at_date'):
params['grouping_query'] = ComplexQuery(
Query(grouping_reference=None),
Query(grouping_date=params['at_date'], range="min"),
operator="OR")
else:
params['grouping_reference'] = None
if from_date or is_pl_account:
# Create a new parameter list to get the previous balance
get_inventory_kw = params.copy()
initial_balance_from_date = from_date
# ignore any at_date that could lay in params
get_inventory_kw.pop('at_date', None)
if period_start_date:
if is_pl_account:
for ledger_category in ledger
]
for ledger_value in ledger_value_list:
params.setdefault('ledger_uid', []).append(ledger_value.getUid())
default_selection_params = params.copy()
default_selection_params['period_start_date'] = period_start_date
default_selection_params[
'movement_portal_type'] = portal.getPortalAccountingMovementTypeList()
default_selection_params['no_mirror_section_uid_cache'] = 1
# if user request report without grouping reference, don't show accounts that only have grouped lines in the period.
if request.get('omit_grouping_reference', False):
if at_date:
params['grouping_query'] = ComplexQuery(Query(grouping_reference=None),
Query(grouping_date=at_date,
range="min"),
logical_operator="OR")
else:
params['grouping_reference'] = None
analytic_column_list = ()
if hide_analytic:
default_selection_params['group_by'] = ('explanation_uid',
'mirror_section_uid',
'payment_uid')
else:
analytic_column_list = context.accounting_module.AccountModule_getAnalyticColumnList(
)
request.set(
'analytic_column_list',
analytic_column_list) # for Movement_getExplanationTitleAndAnalytics
"""Guess the path of categories, taking as input a mapping {base_category:
category}, where category can be the relative_url, the title or the reference
of the category
"""
from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery
portal = context.getPortalObject()
result_dict = {}
for base_category_name, category in category_dict.items():
category_object = \
context.getPortalObject().portal_categories[base_category_name]
category_value = category_object.restrictedTraverse(category, None)
if category_value is None:
query = ComplexQuery(
ComplexQuery(Query(title=category, key='ExactMatch'),
Query(reference=category, key='ExactMatch'),
logical_operator='OR'),
ComplexQuery(Query(relative_url='%s/%%' % base_category_name)))
category_value = portal.portal_catalog.getResultValue(query=query)
if category_value is not None:
# remove base category from relative_url
result_dict[base_category_name] = \
category_value.getRelativeUrl().split('/', 1)[1]
return result_dict
def generateNestedQuery(getQuery,
priority_list,
criterion_dict,
possible_worklist_id_dict=None):
"""
"""
assert possible_worklist_id_dict is None \
or len(possible_worklist_id_dict) != 0
my_priority_list = priority_list[:]
my_criterion_id = my_priority_list.pop()
query_list = []
append = query_list.append
my_criterion_dict = criterion_dict[my_criterion_id]
if len(my_priority_list) > 0:
for criterion_value, worklist_id_dict in my_criterion_dict.iteritems():
if possible_worklist_id_dict is not None:
criterion_worklist_id_dict = worklist_id_dict.copy()
# Do not use iterkeys since the dictionary will be modified in the
# loop
for worklist_id in criterion_worklist_id_dict.keys():
if worklist_id not in possible_worklist_id_dict:
del criterion_worklist_id_dict[worklist_id]
else:
criterion_worklist_id_dict = worklist_id_dict
if len(criterion_worklist_id_dict):
subcriterion_query = generateNestedQuery(
getQuery=getQuery,
priority_list=my_priority_list,
criterion_dict=criterion_dict,
possible_worklist_id_dict=criterion_worklist_id_dict)
if subcriterion_query is not None:
query = getQuery(comparison_operator='IN',
**{my_criterion_id: criterion_value})
if isinstance(criterion_value, ExclusionTuple):
query = NegatedQuery(query)
query = ComplexQuery(
logical_operator='OR',
*(query, getQuery(**{my_criterion_id: None})))
append(
ComplexQuery(query,
subcriterion_query,
logical_operator='AND'))
else:
possible_value_list = tuple()
impossible_value_list = tuple()
possible = True
for criterion_value, criterion_worklist_id_dict \
in my_criterion_dict.iteritems():
if possible_worklist_id_dict is not None:
possible = False
for worklist_id in criterion_worklist_id_dict.iterkeys():
if worklist_id in possible_worklist_id_dict:
possible = True
break
if possible:
if isinstance(criterion_value, ExclusionTuple):
impossible_value_list += criterion_value
else:
possible_value_list += criterion_value
value_query_list = []
if len(possible_value_list):
query = getQuery(comparison_operator='IN',
**{my_criterion_id: possible_value_list})
value_query_list.append(query)
if len(impossible_value_list):
query = getQuery(comparison_operator='IN',
**{my_criterion_id: impossible_value_list})
query = NegatedQuery(query)
query = ComplexQuery(logical_operator='OR',
*(query, getQuery(**{my_criterion_id: None})))
value_query_list.append(query)
append(ComplexQuery(logical_operator='AND', *value_query_list))
if len(query_list):
return ComplexQuery(logical_operator='OR', *query_list)
return None
def getInventoryQueryDict(self, budget_cell):
""" Query dict to pass to simulation query
"""
query_dict = dict()
axis = self.getInventoryAxis()
if not axis:
return query_dict
base_category = self.getProperty('variation_base_category')
if not base_category:
return query_dict
budget_line = budget_cell.getParentValue()
context = budget_cell
if self.isMemberOf('budget_variation/budget'):
context = budget_line.getParentValue()
elif self.isMemberOf('budget_variation/budget_line'):
context = budget_line
if axis == 'movement':
axis = 'default_%s' % base_category
if axis == 'movement_strict_membership':
axis = 'default_strict_%s' % base_category
uid_based_axis = False
if axis in ('node', 'section', 'payment', 'function', 'project',
'mirror_section', 'mirror_node', 'funding' ):
axis = '%s_uid' % axis
uid_based_axis = True
query = None
portal_categories = self.getPortalObject().portal_categories
for criterion_category in context.getMembershipCriterionCategoryList():
if '/' not in criterion_category: # safe ...
continue
criterion_base_category, node_url = criterion_category.split('/', 1)
if criterion_base_category == base_category:
if node_url == 'budget_special_node/none':
# This is the "Nothing" virtual node
query = Query(**{axis: None})
elif node_url == 'budget_special_node/all_other':
# This is the "All Other" virtual node
other_uid_list = []
none_node_selected = False
for node in self._getNodeList(budget_line):
if '%s/%s' % (base_category, node.getRelativeUrl()) in\
budget_line.getVariationCategoryList():
if node.getRelativeUrl() == 'budget_special_node/none':
none_node_selected = True
else:
if uid_based_axis:
other_uid_list.append(node.getUid())
else:
other_uid_list.append(node.getRelativeUrl())
if none_node_selected:
# in this case we don't want to include NULL in All others
query = NegatedQuery(Query(**{axis: other_uid_list}))
else:
query = ComplexQuery(
NegatedQuery(Query(**{axis: other_uid_list})),
Query(**{axis: None}),
operator="OR")
else:
value = portal_categories.getCategoryValue(node_url,
base_category=criterion_base_category)
if uid_based_axis:
query_dict.setdefault(axis, []).append(value.getUid())
else:
query_dict.setdefault(axis, []).append(value.getRelativeUrl())
if query:
if axis in query_dict:
query_dict[axis] = ComplexQuery(
query,
Query(**{axis: query_dict[axis]}),
operator='OR')
else:
query_dict[axis] = query
return query_dict
# the id_group is extended with the group path so that
# each local registry has a different sequence
group = (date.year(), )
new_registry_number = request_eform.portal_ids.generateNewId(
id_group=group, method=attachLocationYearInfo)
# build a query and search in person module if the person already exists,
# if the person does not exist, create the person and a new assignment for
# the person with function commercant on the organisation if the
# person exist, just add a new assignment for the person with the function
# commercant on organisation
query = ComplexQuery(
Query(title=request_eform.getTitle()),
Query(birth_date=request_eform.getStartDate()),
Query(birthplace_city=request_eform.getDefaultBirthplaceAddressCity()),
logical_operator="AND")
person_list = [
person.getObject() for person in person_module.searchFolder(query=query)
]
if request_eform.getBeginning() or request_eform.getOpening():
if len(person_list) == 0:
person = person_module.newContent(portal_type='Person')
person.edit(first_name=request_eform.getFirstName(),
last_name=request_eform.getLastName(),
default_address_street_address=request_eform.
getHeadOfficeAddress(),
start_date=request_eform.getStartDate(),
default_birthplace_address_city=request_eform.
getDefaultBirthplaceAddressCity(),
def asQuery(self, strict_membership=False):
"""
A Predicate can be rendered as a set of catalog conditions. This
can be useful to create reporting trees based on the
ZSQLCatalog. This condition set is however partial since
python scripts which are used by the test method of the predicate
cannot be converted to catalog conditions. If a python script is defined to
implement test, results obtained through asQuery must be additionnaly
tested by invoking test().
"""
portal_catalog = self.getPortalObject().portal_catalog
buildSingleQuery = portal_catalog.getSQLCatalog().buildSingleQuery
getCategoryParameterDict = portal_catalog.getCategoryParameterDict
def filterCategoryList(base_category_set, category_list):
return [
x for x in category_list
if x.split('/', 1)[0] in base_category_set
]
next_join_counter = itertools.count().next
def buildSeparateJoinQuery(name, value):
query = buildSingleQuery(name, value)
suffix = str(next_join_counter())
# XXX: using a deprecated API and accessing properties which are not part
# of the API. Of course this will never break !
query.setTableAliasList([
(x, x + suffix) for x in query.search_key.table_list
])
return query
query_list = []
append = query_list.append
for buildQuery, getBaseCategorySet, getCategoryList in (
( # Single-membership criterion
lambda name, value: buildSingleQuery(name, value),
self.getMembershipCriterionBaseCategoryList,
self.getMembershipCriterionCategoryList,
),
( # Multi-membership criterion
buildSeparateJoinQuery,
self.getMultimembershipCriterionBaseCategoryList,
self.getMembershipCriterionCategoryList,
),
):
append(
getCategoryParameterDict(
filterCategoryList(getBaseCategorySet(), getCategoryList()),
strict_membership=strict_membership,
onMissing=lambda category: False,
),
)
# Value criterion
for criterion in self.getCriterionList():
if not criterion.min and not criterion.max:
append(buildSingleQuery(criterion.property, criterion.identity))
continue
if criterion.min:
append(SimpleQuery(
comparison_operator='>=',
**{criterion.property: criterion.min}
))
if criterion.max:
append(SimpleQuery(
comparison_operator='<=',
**{criterion.property: criterion.max}
))
if query_list:
return ComplexQuery(query_list, logical_operator='AND')
elif not getattr(self, 'isEmptyCriterionValid', lambda: True)():
# By catalog definition, no object has uid 0, so this condition forces an
# empty result.
return SimpleQuery(uid=0)
return SimpleQuery(uid=0, comparison_operator='>')
attachment_pdf_list=[]
current_object = context.getObject()
event_list = current_object.getFollowUpRelatedValueList()
attachment_list =[x.getAggregateValueList() for x in event_list]
for y in attachment_list:
attachment_pdf_list.extend(filter(lambda x:(x.getPortalType()=='PDF'),y))
event_uid_list = map(lambda x: x.getUid(), event_list)
attachment_pdf_uid_list =[x.getUid() for x in attachment_pdf_list]
if not event_uid_list:
return []
# Build query
query = ComplexQuery(Query(parent_uid=event_uid_list),
Query(uid=event_uid_list),
Query(parent_uid=attachment_pdf_uid_list),
Query(uid=attachment_pdf_uid_list),
operator="OR")
kw['portal_type'] = ('PDF')
result_uid = [x.getUid() for x in context.portal_catalog(query=query, **kw)]
result_document = [x.getObject() for x in context.portal_catalog(query=query, **kw)]
display = 'thumbnail'
format = 'jpg'
resolution ='75'
for doc in result_document:
content_information = doc.getContentInformation()
page_number = int(content_information.get('Pages', 0))
page_list = range(page_number)
page_number_list = []
for i in page_list:
def getSecurityQuery(self,
query=None,
sql_catalog_id=None,
local_roles=None,
**kw):
"""
Build a query based on allowed roles or on a list of security_uid
values. The query takes into account the fact that some roles are
catalogued with columns.
"""
user = _getAuthenticatedUser(self)
user_str = str(user)
user_is_superuser = (user == system_user) or (user_str == SUPER_USER)
if user_is_superuser:
# We need no security check for super user.
return query
original_query = query
security_uid_dict, role_column_dict, local_role_column_dict = \
self.getSecurityUidDictAndRoleColumnDict(
sql_catalog_id=sql_catalog_id,
local_roles=local_roles,
)
role_query = None
security_uid_query = None
if role_column_dict:
query_list = []
for key, value in role_column_dict.items():
new_query = Query(**{key: value})
query_list.append(new_query)
operator_kw = {'operator': 'OR'}
role_query = ComplexQuery(*query_list, **operator_kw)
if security_uid_dict:
catalog_security_uid_groups_columns_dict = \
self.getSQLCatalog().getSQLCatalogSecurityUidGroupsColumnsDict()
query_list = []
for local_roles_group_id, security_uid_list in\
security_uid_dict.iteritems():
assert security_uid_list
query_list.append(
Query(
**{
catalog_security_uid_groups_columns_dict[local_roles_group_id]:
security_uid_list,
'operator':
'IN'
}))
security_uid_query = ComplexQuery(*query_list, operator='OR')
if role_query:
if security_uid_query:
# merge
query = ComplexQuery(security_uid_query,
role_query,
operator='OR')
else:
query = role_query
elif security_uid_query:
query = security_uid_query
else:
# XXX A false query has to be generated.
# As it is not possible to use SQLKey for now, pass impossible value
# on uid (which will be detected as False by MySQL, as it is not in the
# column range)
# Do not pass security_uid_list as empty in order to prevent useless
# overhead
query = Query(uid=-1)
if local_role_column_dict:
query_list = []
for key, value in local_role_column_dict.items():
new_query = Query(**{key: value})
query_list.append(new_query)
operator_kw = {'operator': 'AND'}
local_role_query = ComplexQuery(*query_list, **operator_kw)
query = ComplexQuery(query, local_role_query, operator='AND')
if original_query is not None:
query = ComplexQuery(query, original_query, operator='AND')
return query
# To make `translated_title` behave like `title`, we support the LIKE operator.
# If user made a search with %, we treat it as a LIKE.
operator_value_dict, logical_operator, _ = search_key.processSearchValue(
detect_like=True,
search_value=search_value,
default_logical_operator=logical_operator,
comparison_operator=comparison_operator,
)
if 'like' in operator_value_dict:
return AndQuery(
ComplexQuery(
[
SimpleQuery(
**{
'content_translation.translated_text': search_term,
'comparison_operator': 'like'
}) for search_term in operator_value_dict['like']
],
logical_operator=logical_operator,
),
Query(**{'content_translation.property_name': 'title'}),
)
# This scriptable key supports content_translation if the table is present
catalog = portal.portal_catalog.getSQLCatalog()
if 'content_translation' in catalog.getSqlSearchTablesList():
if [x for x in catalog.getSqlCatalogSearchKeysList() if 'Mroonga' in x]:
return AndQuery(
SimpleQuery(
**{
'content_translation.translated_text': search_value,
from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery
kw.pop('relative_url', None)
kw.pop('follow_up_uid', None)
portal = context.getPortalObject()
portal_catalog = portal.portal_catalog
if portal_type is None:
portal_type = portal.getPortalDocumentTypeList(
) + portal.getPortalEmbeddedDocumentTypeList()
limit = kw.pop('limit', None)
follow_up_related_document_list = portal_catalog(
portal_type=portal_type, follow_up_uid=context.getUid(), **kw)
if follow_up_related_document_list:
document_query = ComplexQuery(
Query(relative_url='%s/%%' %
context.getRelativeUrl().replace('_', r'\_')),
Query(uid=[x.getUid() for x in follow_up_related_document_list]),
logical_operator='or')
else:
document_query = Query(relative_url='%s/%%' %
context.getRelativeUrl().replace('_', r'\_'))
if query is None:
query = document_query
else:
query = ComplexQuery(query, document_query, logical_operator='and')
return portal_catalog(portal_type=portal_type, query=query, limit=limit, **kw)
from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery
if document_type == 'Image':
portal_type = ['Image']
else:
portal_type = [
x for x in context.getPortalDocumentTypeList() if x != 'Image'
]
return ComplexQuery(Query(portal_type=portal_type),
ComplexQuery(Query(
validation_state=('published', 'published_alive',
'released', 'released_alive',
'shared', 'shared_alive'),
reference='!=None'),
Query(validation_state='embedded',
parent_uid=context.getUid()),
operator='or'),
operator='and')
if creation_from:
query_list.append(
SimpleQuery(creation_date=creation_from.strftime('>=' + date_format)))
if creation_to:
query_list.append(
SimpleQuery(creation_date=creation_to.strftime('<=' + date_format)))
if modification_from:
query_list.append(
SimpleQuery(modification_date=modification_from.strftime('>=' +
date_format)))
if modification_to:
query_list.append(
SimpleQuery(modification_date=modification_to.strftime('<=' +
date_format)))
if query_list:
query_kw['query'] = ComplexQuery(query_list, logical_operator='and')
if parsed_search_string.get('mine', None) is not None:
# user wants only his documents
query_kw['owner'] = portal.portal_membership.getAuthenticatedMember(
).getId()
# add contributor title
contributor_title = parsed_search_string.get('contributor_title', None)
if contributor_title is not None:
query_kw['contributor_title'] = contributor_title
if parsed_search_string.get('newest', None) is not None:
#...and now we check for only the newest versions
# but we need to preserve order
query_kw['group_by'] = ('reference', )
from Products.PythonScripts.standard import Object
portal = context.getPortalObject()
assert account_type in ('account_type/asset/receivable',
'account_type/liability/payable')
currency = context.Base_getCurrencyForSection(section_category)
precision = context.account_module.getQuantityPrecisionFromResource(currency)
# we set the precision in request, for formatting on editable fields
portal.REQUEST.set('precision', precision)
section_uid = portal.Base_getSectionUidListForSectionCategory(
section_category, section_category_strict)
grouping_query = ComplexQuery(SimpleQuery(grouping_reference=None),
SimpleQuery(grouping_date=at_date,
comparison_operator=">="),
logical_operator="OR")
account_number_memo = {}
def getAccountNumber(account_url):
try:
return account_number_memo[account_url]
except KeyError:
account_number_memo[account_url] =\
portal.restrictedTraverse(account_url).Account_getGapId()
return account_number_memo[account_url]
section_title_memo = {None: ''}
from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery
kw.pop('relative_url', None)
kw.pop('follow_up_uid', None)
portal_catalog=context.getPortalObject().portal_catalog
project_object_list = portal_catalog(
portal_type=portal_type,
source_project_title=context.getTitle(), **kw)
kw['query'] = Query(relative_url='%s/%%' % context.getRelativeUrl().replace('_', r'\_'))
if project_object_list:
kw['query'] = ComplexQuery(
kw['query'],
Query(uid=[x.getUid() for x in project_object_list]),
logical_operator='or')
return portal_catalog(portal_type=portal_type, limit=limit, **kw)
# Initialise query
query_list = []
# Assemble query
for action in ordered_global_action_list:
workflow_id = action.get('workflow_id', None)
worklist_id = action.get('worklist_id', None)
if workflow_id is not None and worklist_id is not None:
# get worklist defined local roles
local_roles = context.Base_getWorkflowWorklistInfo(workflow_id, worklist_id)
query_dict = context.WebSite_getWorklistSettingsFor(action)
if query_dict:
sub_query_list = []
for k, v in query_dict.items():
sub_query_list.append(Query(**{k: v}))
complex_query = ComplexQuery(logical_operator="AND", *sub_query_list)
# add to query filtering by local roles as defined in worklist
complex_query = portal.portal_catalog.getSecurityQuery(query=complex_query, local_roles=local_roles)
query_list.append(complex_query)
# Return empty list if nothing defined
if not query_list:
if kw.get('_count', 0):
return [[0]]
else:
return []
# Invoke catalog
query = ComplexQuery(logical_operator="OR", *query_list)
#query = portal.portal_catalog.getSecurityQuery(query)
#result_list = portal.portal_catalog(query=query,
ledger = ledger or request.get('ledger')
if ledger:
search_kw['ledger_uid'] = [
portal.portal_categories.restrictedTraverse(x).getUid() for x in ledger
]
if grouping == 'grouping':
search_kw['grouping_reference'] = None
else:
assert grouping == 'ungrouping', grouping
search_kw['grouping_reference'] = NegatedQuery(
Query(grouping_reference=None))
if title:
search_kw['title_query'] = ComplexQuery(Query(title=title),
Query(parent_title=title),
logical_operator='OR')
if delivery_reference:
search_kw['parent_reference'] = delivery_reference
if debit_price:
search_kw['stock.total_price'] = debit_price
if credit_price:
try:
search_kw['stock.total_price'] = -float(credit_price['query'])
except ValueError, e:
# happens when user entered a complex query (like "> 100 AND < 200")
# in that case, there is not much we can do.
search_kw['stock.total_price'] = credit_price['query']
if date:
search_kw['stock.date'] = date
# Find the applicable language
if language is None:
language = portal.Localizer.get_selected_language()
if validation_state is None:
validation_state = ('released', 'released_alive', 'published',
'published_alive', 'shared', 'shared_alive', 'public',
'validated')
if effective_date is None:
if now is None:
now = DateTime()
effective_date = ComplexQuery(
SimpleQuery(effective_date=None),
SimpleQuery(effective_date=now, comparison_operator='<='),
logical_operator='or',
)
# Note: In sorts, NULL is considered lesser than non-NULL. So in descending
# sort, NULLs will be listed after non-NULLs, which is perfect for
# effective_date, which defines the date at which content becomes effective.
# None (NULL) effective date hence means "effective since infinite in te past".
base_sort = (('effective_date', 'descending'), )
# Portal Type and validation state should be handled by predicate
# By default
document_list = context.searchResults(reference=name,
effective_date=effective_date,
language=(language, ''),
sort_on=(('language', 'descending'), ) +
def getInventoryListQueryDict(self, budget_line):
"""Returns the query dict to pass to simulation query for a budget line
"""
axis = self.getInventoryAxis()
if not axis:
return dict()
base_category = self.getProperty('variation_base_category')
if not base_category:
return dict()
context = budget_line
if self.isMemberOf('budget_variation/budget'):
context = budget_line.getParentValue()
portal_categories = self.getPortalObject().portal_categories
query_dict = dict()
uid_based_axis = False
if axis == 'movement':
axis = 'default_%s_uid' % base_category
query_dict['select_list'] = [axis]
query_dict['group_by'] = [axis]
uid_based_axis = True
elif axis == 'movement_strict_membership':
axis = 'default_strict_%s_uid' % base_category
query_dict['select_list'] = [axis]
query_dict['group_by'] = [axis]
uid_based_axis = True
else:
query_dict['group_by_%s' % axis] = True
if axis in ('node', 'section', 'payment', 'function', 'project',
'mirror_section', 'mirror_node', 'funding' ):
axis = '%s_uid' % axis
uid_based_axis = True
# if we have a virtual "all others" node, we don't set a criterion here.
if self.getProperty('include_virtual_other_node'):
return query_dict
if self.getProperty('full_consumption_detail'):
if self.isMemberOf('budget_variation/budget'):
category_list = [item[1] for item in
self.getBudgetVariationRangeCategoryList(context)]
else:
category_list = [item[1] for item in
self.getBudgetLineVariationRangeCategoryList(context)]
else:
category_list = context.getVariationCategoryList(
base_category_list=(base_category,))
found = False
for node_url in category_list:
if node_url != '%s/budget_special_node/none' % base_category:
__traceback_info__ = (node_url, )
if uid_based_axis:
query_dict.setdefault(axis, []).append(
portal_categories.getCategoryValue(node_url,
base_category=base_category).getUid())
else:
query_dict.setdefault(axis, []).append(
portal_categories.getCategoryValue(node_url,
base_category=base_category).getRelativeUrl())
found = True
if found:
if self.getProperty('include_virtual_none_node'):
if axis in query_dict:
query_dict[axis] = ComplexQuery(
Query(**{axis: None}),
Query(**{axis: query_dict[axis]}),
operator="OR")
else:
query_dict[axis] = Query(**{axis: None})
return query_dict
return dict()
# Aggregate the Pay Sheet Transactions that will be declared in
# the current DSN Report.
# Pay Sheet Transactions are chosen by date and establishment
from Products.ZSQLCatalog.SQLCatalog import ComplexQuery, Query
portal = context.getPortalObject()
destination_trade = portal.restrictedTraverse(destination_trade_category)
catalog_kw = {
'query':
ComplexQuery(Query(start_date=">=%s" % from_date.strftime("%Y/%m/%d")),
Query(stop_date="<=%s" % to_date.strftime("%Y/%m/%d")),
Query(destination_trade_uid=Query(
destination_trade_uid=destination_trade.getUid())),
Query(simulation_state='!=cancelled'),
Query(simulation_state='!=deleted'),
Query(simulation_state='!=draft'),
logical_operator="AND")
}
paysheet_list = portal.accounting_module.searchFolder(
portal_type="Pay Sheet Transaction", **catalog_kw)
for paysheet in paysheet_list:
paysheet = paysheet.getObject()
aggregate_list = paysheet.getAggregateList([])
if context.getRelativeUrl() not in aggregate_list:
aggregate_list.append(context.getRelativeUrl())
paysheet.edit(aggregate_list=aggregate_list)
def _searchPredicateList(self,
context,
test=1,
sort_method=None,
ignored_category_list=None,
tested_base_category_list=None,
filter_method=None,
acquired=1,
sort_key_method=None,
query=None,
restricted=False,
**kw):
"""
Search all predicates which corresponds to this particular
context.
- sort_method parameter should not be used, if possible, because
it can be very slow. Use sort_key_method instead.
- sort_key_method parameter is passed to list.sort as key parameter if it
is not None. This allows to sort the list of predicates found. The most
important predicate is the first one in the list.
- ignored_category_list: this is the list of category that we do
not want to test. For example, we might want to not test the
destination or the source of a predicate.
- tested_base_category_list: this is the list of category that we do
want to test. For example, we might want to test only the
destination or the source of a predicate.
- the acquired parameter allows to define if we want to use
acquisition for categories. By default we want.
"""
if not kw.pop('strict', True):
raise ValueError('"strict" mode cannot be disabled anymore')
portal = self.getPortalObject()
portal_catalog = portal.portal_catalog
portal_categories = portal.portal_categories
# Search the columns of the predicate table
query_list = [] if query is None else [query]
for column in portal_catalog.getSQLCatalog().getTableColumnList(
'predicate'):
# Arbitrary suffix choice, this code expects COLUMN, COLUMN_range_min
# and COLUMN_range_max to be simultaneously present for ranged
# properties. Only checking one suffix simplifies the code flow.
if column.endswith('_range_min'):
property_name = column[:-10]
# We have to check a range property
equality = 'predicate.' + property_name
range_min = equality + '_range_min'
range_max = equality + '_range_max'
value = context.getProperty(property_name)
query = ComplexQuery(SimpleQuery(**{equality: None}),
SimpleQuery(**{range_min: None}),
SimpleQuery(**{range_max: None}),
logical_operator='AND')
if value is not None:
query = ComplexQuery(
query,
SimpleQuery(**{equality: value}),
ComplexQuery(
SimpleQuery(comparison_operator='<=',
**{range_min: value}),
SimpleQuery(**{range_max: None}),
logical_operator='AND',
),
ComplexQuery(
SimpleQuery(**{range_min: None}),
SimpleQuery(comparison_operator='>=',
**{range_max: value}),
logical_operator='AND',
),
ComplexQuery(
SimpleQuery(comparison_operator='<=',
**{range_min: value}),
SimpleQuery(comparison_operator='>=',
**{range_max: value}),
logical_operator='AND',
),
logical_operator='OR',
)
query_list.append(query)
if tested_base_category_list != []:
# Add category selection
if tested_base_category_list is None:
if acquired:
category_list = context.getAcquiredCategoryList()
else:
category_list = context.getCategoryList()
else:
if acquired:
getter = context.getAcquiredCategoryMembershipList
else:
getter = context.getCategoryMembershipList
category_list = []
extend = category_list.extend
for tested_base_category in tested_base_category_list:
if portal_categories.get(tested_base_category) is None:
raise ValueError('Unknown base category: %r' %
(tested_base_category, ))
tested_category_list = getter(tested_base_category, base=1)
if tested_category_list:
extend(tested_category_list)
else:
# Developer requested specific base categories, but context do not
# declare one of these. Skipping this criterion risks matching too
# many predicates, breaking the system performance-wise. So let
# developer know there is an unexpected situation by raising.
raise ValueError('%r does not have any %r relation' % (
context.getPath(),
tested_base_category,
))
left_join_list = kw.get('left_join_list', [])[:]
inner_join_list = kw.get('inner_join_list', [])[:]
if category_list:
preferred_predicate_category_list = portal.portal_preferences.getPreferredPredicateCategoryList(
[])
left_join_category_list = []
inner_join_category_list = []
for category in category_list:
if portal_categories.getBaseCategoryId(
category) in preferred_predicate_category_list:
inner_join_category_list.append(category)
else:
left_join_category_list.append(category)
def onMissing(category):
# BBB: ValueError would seem more appropriate here, but original code
# was raising TypeError - and this is explicitely tested for.
raise TypeError('Unknown category: %r' % (category, ))
def onInnerJoin(column_name):
inner_join_list.append(column_name)
# Base category is part of preferred predicate categories, predicates
# which ignore it are indexed with category_uid=0.
return SimpleQuery(**{column_name: 0})
query_list.append(
portal_catalog.getCategoryParameterDict(
inner_join_category_list,
category_table='predicate_category',
onMissing=onMissing,
onJoin=onInnerJoin,
))
def onLeftJoin(column_name):
left_join_list.append(column_name)
# Base category is not part of preferred predicate categories,
# predicates which ignore it get no predicate_category row inserted
# for it, so an SQL NULL appears, translating to None.
return SimpleQuery(**{column_name: None})
query_list.append(
portal_catalog.getCategoryParameterDict(
left_join_category_list,
category_table='predicate_category',
onMissing=onMissing,
onJoin=onLeftJoin,
))
else:
# No category to match against, so predicates expecting any relation
# would not apply, so we can exclude these.
# Note: this relies on a special indexation mechanism for predicate
# categories, which inserts a base_category_uid=0 line when indexed
# predicate membership_criterion_category_list is empty.
base_category_uid_column = 'predicate_category.base_category_uid'
kw[base_category_uid_column] = 0
inner_join_list.append(base_category_uid_column)
kw['left_join_list'] = left_join_list
kw['inner_join_list'] = inner_join_list
if query_list:
kw['query'] = ComplexQuery(logical_operator='AND', *query_list)
if restricted:
sql_result_list = portal_catalog.searchResults(**kw)
else:
sql_result_list = portal_catalog.unrestrictedSearchResults(**kw)
if kw.get('src__'):
return sql_result_list
result_list = []
if sql_result_list:
if test:
cache = {}
def isMemberOf(context, c, strict_membership):
if c in cache:
return cache[c]
cache[c] = result = portal_categories.isMemberOf(
context, c, strict_membership=strict_membership)
return result
for predicate in sql_result_list:
predicate = predicate.getObject()
if not test or predicate.test(context,
tested_base_category_list,
isMemberOf=isMemberOf):
result_list.append(predicate)
if filter_method is not None:
result_list = filter_method(result_list)
if sort_key_method is not None:
result_list.sort(key=sort_key_method)
elif sort_method is not None:
result_list.sort(cmp=sort_method)
return result_list
from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery
kw.pop('relative_url', None)
kw.pop('follow_up_uid', None)
portal = context.getPortalObject()
portal_catalog = portal.portal_catalog
if portal_type is None:
portal_type = portal.getPortalDocumentTypeList(
) + portal.getPortalEmbeddedDocumentTypeList()
limit = kw.pop('limit', None)
follow_up_related_document_list = portal_catalog(
portal_type=portal_type,
follow_up_uid=context.getUid(),
)
document_query = Query(relative_url='%s/%%' %
context.getRelativeUrl().replace('_', r'\_'))
if follow_up_related_document_list:
document_query = ComplexQuery(
document_query,
Query(uid=[x.getUid() for x in follow_up_related_document_list]),
logical_operator='or')
if query is None:
query = document_query
else:
query = ComplexQuery(query, document_query, logical_operator='and')
return portal_catalog(portal_type=portal_type, query=query, limit=limit, **kw)
request = context.REQUEST
portal_catalog = context.portal_catalog
reference = request.get('reference')
data_chunk = request.get('data_chunk')
if data_chunk is not None and reference is not None:
# here we rely that fluentd will pass to us its tag which we use
# as reference but we can extract it sometimes from sensor data
# it thus depends on sensor and the fluentd topography
query = ComplexQuery(Query(portal_type='Data Supply'),
Query(reference=reference),
Query(validation_state='validated'),
Query(**{
'delivery.stop_date': now,
'range': 'min'
}),
Query(**{
'delivery.start_date': now,
'range': 'max'
}),
logical_operator="AND")
data_supply = portal_catalog.getResultValue(query=query)
#context.log(data_supply)
# we can have multiple lines for each sensor and we filter out by reference
# XXX: in future we will use Predicates to find already generated
# Data Ingestion (Movements)
if data_supply is not None:
for data_supply_line in data_supply.objectValues():
sensor = data_supply_line.getSourceValue()
if sensor is not None and sensor.getReference() == reference:
def _searchPredicateList(self,
context,
test=1,
sort_method=None,
ignored_category_list=None,
tested_base_category_list=None,
filter_method=None,
acquired=1,
strict=True,
sort_key_method=None,
query=None,
restricted=False,
**kw):
# XXX: about "strict" parameter: This is a transition parameter,
# allowing someone hitting a bug to revert to original behaviour easily.
# It is not a correct name, as pointed out by Jerome. But instead of
# searching for another name, it would be much better to just remove it.
"""
Search all predicates which corresponds to this particular
context.
- sort_method parameter should not be used, if possible, because
it can be very slow. Use sort_key_method instead.
- sort_key_method parameter is passed to list.sort as key parameter if it
is not None. This allows to sort the list of predicates found. The most
important predicate is the first one in the list.
- ignored_category_list: this is the list of category that we do
not want to test. For example, we might want to not test the
destination or the source of a predicate.
- tested_base_category_list: this is the list of category that we do
want to test. For example, we might want to test only the
destination or the source of a predicate.
- the acquired parameter allows to define if we want to use
acquisition for categories. By default we want.
- strict: if True, generate SQL which will match predicates matching
all those categories at the same time, except for categories they do
not check at all. Example:
Predicate_1 checks foo/bar
Predicate_2 checks foo/baz region/somewhere
Predicate_3 checks foo/bar region/somewhere
When called with category list ['foo/bar', 'region/somewhere'] and
strict parameter to True, it will return [Predicate_1, Predicate_3].
With strict to False or by not giving a category list, it would also
return Predicate_2, because it matches on one criterion out of the 2
it checks.
Note that it changes the value returned by this function if it was
invoked with "test=False" value. Otherwise, it should only change
execution duration.
"""
portal = self.getPortalObject()
portal_catalog = portal.portal_catalog
portal_categories = portal.portal_categories
# Search the columns of the predicate table
range_column_set = set()
query_list = [] if query is None else [query]
for column in portal_catalog.getColumnIds():
if column[:10] == 'predicate.' and \
column[-10:] in ('_range_min', '_range_max'):
property_name = column[10:-10]
if property_name not in range_column_set:
range_column_set.add(property_name)
# We have to check a range property
equality = 'predicate.' + property_name
range_min = equality + '_range_min'
range_max = equality + '_range_max'
value = context.getProperty(property_name)
query = ComplexQuery(Query(**{equality: None}),
Query(**{range_min: None}),
Query(**{range_max: None}),
logical_operator='AND')
if value is not None:
query = ComplexQuery(
query,
ComplexQuery(
Query(**{equality: value}),
ComplexQuery(
ComplexQuery(
Query(
**{
range_min:
dict(
query=value,
range='ngt',
)
}),
Query(**{range_max: None}),
logical_operator='AND',
),
ComplexQuery(
Query(**{range_min: None}),
Query(
**{
range_max:
dict(
query=value,
range='min',
)
}),
logical_operator='AND',
),
ComplexQuery(
Query(
**{
range_min:
dict(
query=value,
range='ngt',
)
}),
Query(
**{
range_max:
dict(
query=value,
range='min',
)
}),
logical_operator='AND',
),
logical_operator='OR',
),
logical_operator='OR',
),
logical_operator='OR')
query_list.append(query)
# Add category selection
if tested_base_category_list is None:
if acquired:
category_list = context.getAcquiredCategoryList()
else:
category_list = context.getCategoryList()
else:
if acquired:
getter = context.getAcquiredCategoryMembershipList
else:
getter = context.getCategoryMembershipList
category_list = []
extend = category_list.extend
for tested_base_category in tested_base_category_list:
extend(getter(tested_base_category, base=1))
if tested_base_category_list != []:
preferred_predicate_category_list = portal.portal_preferences.getPreferredPredicateCategoryList(
)
if (preferred_predicate_category_list
and tested_base_category_list is not None
and set(preferred_predicate_category_list).issuperset(
tested_base_category_list)):
# New behavior is enabled only if preferred predicate category is
# defined and tested_base_category_list is passed.
predicate_category_query_list = []
predicate_category_table_name_list = []
category_dict = {}
for relative_url in category_list:
category_value = portal_categories.getCategoryValue(
relative_url)
base_category_id = portal_categories.getBaseCategoryId(
relative_url)
base_category_value = portal_categories.getCategoryValue(
base_category_id)
if not base_category_value in category_dict:
category_dict[base_category_value] = []
category_dict[base_category_value].append(category_value)
for base_category_value, category_value_list in category_dict.iteritems(
):
if base_category_value.getId(
) in preferred_predicate_category_list:
table_index = len(predicate_category_query_list)
predicate_category_table_name = 'predicate_category_for_domain_tool_%s' % table_index
table_alias_list = [('predicate_category',
predicate_category_table_name)]
predicate_category_query_list.append(
ComplexQuery(
Query(predicate_category_base_category_uid=
base_category_value.getUid(),
table_alias_list=table_alias_list),
Query(
predicate_category_category_strict_membership
=1,
table_alias_list=table_alias_list),
ComplexQuery(
Query(predicate_category_category_uid=[
category_value.getUid() for
category_value in category_value_list
],
table_alias_list=table_alias_list),
Query(
predicate_category_category_uid='NULL',
table_alias_list=table_alias_list),
logical_operator='OR'),
logical_operator='AND'))
if not predicate_category_query_list:
# Prevent matching everything
predicate_category_query_list.append(
Query(predicate_category_base_category_uid=0))
predicate_category_query = ComplexQuery(
logical_operator='AND', *predicate_category_query_list)
query_list.append(predicate_category_query)
else:
# Traditional behavior
category_expression_dict = portal_categories.buildAdvancedSQLSelector(
category_list or ['NULL'],
query_table='predicate_category',
none_sql_value=0,
strict=strict)
where_expression = category_expression_dict['where_expression']
if where_expression:
kw['where_expression'] = SQLQuery(where_expression)
if 'from_expression' in category_expression_dict:
kw['from_expression'] = category_expression_dict[
'from_expression']
else:
# Add predicate_category.uid for automatic join
kw['predicate_category.uid'] = '!=NULL'
if query_list:
kw['query'] = ComplexQuery(logical_operator='AND', *query_list)
if restricted:
sql_result_list = portal_catalog.searchResults(**kw)
else:
sql_result_list = portal_catalog.unrestrictedSearchResults(**kw)
if kw.get('src__'):
return sql_result_list
result_list = []
for predicate in sql_result_list:
predicate = predicate.getObject()
if (not test) or predicate.test(
context,
tested_base_category_list=tested_base_category_list):
result_list.append(predicate)
if filter_method is not None:
result_list = filter_method(result_list)
if sort_key_method is not None:
result_list.sort(key=sort_key_method)
elif sort_method is not None:
result_list.sort(cmp=sort_method)
return result_list
real_key = key[:-7]
new_mapping['%s_value_' % real_key] = new_mapping[real_key]
new_mapping['%s_usage_' % real_key] = value
# TODO: this is a quick and dirty implementation of what should be done by
# Query.asSearchTextExpression. Instead of keeping '%s_value_' and '%s_usage_',
# we'll simply keep the query.
new_mapping[real_key] = '%s %s' % (usage_map[value], new_mapping[real_key])
else:
if request.form.get('%s_is_excluded_' % key):
# Build a negated query
nq_kw = {'strict_%s' % key : value}
q_kw = {key : None}
left_join_list.append(key)
left_join_list.append('strict_%s' % key)
query_list.append(ComplexQuery(NegatedQuery(Query(**nq_kw)), Query(**q_kw), logical_operator="OR"))
new_mapping[key] = ""
new_mapping["dialog_%s" %(key,)] = value
new_mapping["dialog_excluded_%s" %(key,)] = True
else:
if request.form.get('%s_is_strict_' % key):
new_mapping['strict_%s' % key] = value
new_mapping['dialog_strict_%s' % key] = value
else:
new_mapping[key] = value
new_mapping['dialog_%s' % key] = value
new_mapping["query"] = ComplexQuery(query_list)
new_mapping['left_join_list'] = left_join_list
from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery
kw['query'] = ComplexQuery(
Query(portal_type='Simulation Movement',
explanation_portal_type='Returned Purchase Order'),
ComplexQuery(Query(parent_specialise_portal_type=[
'Order Rule', 'Delivery Rule', 'Delivery Root Simulation Rule'
],
simulation_state='confirmed'),
Query(
parent_specialise_portal_type='Delivery Simulation Rule',
grand_parent_simulation_state='confirmed'),
logical_operator='or'),
logical_operator='and')
kw['delivery_uid'] = None
kw['left_join_list'] = ['delivery_uid']
kw['select_dict'] = dict(delivery_uid=None)
kw['group_by'] = ('uid', )
kw['src__'] = src__
return context.portal_catalog(**kw)