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 _checkConsistency(self, obj, fixit=0):
"""Check the object's consistency.
We will make sure that each non None constraint_definition is
satisfied (unicity)
This Constraint use portal_catalog
"""
errors = PropertyExistence._checkConsistency(self, obj, fixit=fixit)
for attribute_name, expression_criterion_dict in self.constraint_definition.items():
message_id = None
mapping = dict(attribute_name=attribute_name)
#Evaluate expression_criterion_dict
expression = Expression(expression_criterion_dict)
from Products.ERP5Type.Utils import createExpressionContext
econtext = createExpressionContext(obj)
criterion_dict = expression(econtext)
from Products.ZSQLCatalog.SQLCatalog import Query, NegatedQuery
# Add uid in criterion keys to avoid fetching current object.
criterion_dict['query'] = NegatedQuery(Query(uid=obj.getUid()))
portal = obj.getPortalObject()
result = portal.portal_catalog.countResults(**criterion_dict)[0][0]
if result >= 1:
mapping['value'] = criterion_dict.get(attribute_name)
message_id = 'message_invalid_attribute_unicity'
# Generate error
if message_id is not None:
errors.append(self._generateError(obj,
self._getMessage(message_id), mapping))
return errors
def _checkConsistency(self, obj, fixit=0):
"""Check the object's consistency.
We will make sure that each non None constraint_definition is
satisfied (unicity)
This Constraint use portal_catalog
"""
error_list = PropertyExistenceConstraint._checkConsistency(self, obj,
fixit=fixit)
attribute_name = self.getConstraintProperty()
expression_criterion_dict = self.getFilterParameter()
message_id = None
mapping = dict(attribute_name=attribute_name)
#Evaluate expression_criterion_dict
expression = Expression(expression_criterion_dict)
econtext = createExpressionContext(obj)
criterion_dict = expression(econtext)
# Add uid in criterion keys to avoid fetching current object.
criterion_dict['query'] = NegatedQuery(Query(uid=obj.getUid()))
portal = obj.getPortalObject()
result = portal.portal_catalog.countResults(**criterion_dict)[0][0]
if result >= 1:
mapping['value'] = criterion_dict.get(attribute_name)
message_id = 'message_invalid_attribute_unicity'
# Generate error
if message_id is not None:
error_list.append(self._generateError(obj,
self._getMessage(message_id), mapping))
return error_list
def buildIndex(language=None):
from Products.ZSQLCatalog.SQLCatalog import NegatedQuery, Query
# Retrieve the different subjects in the catalog
subject_list = context.searchResults(
select_list=['subject', 'reference'],
query=NegatedQuery(Query(subject=None)),
language=language or '',
sort_on=(('subject', 'ascending'), ('title', 'ascending')),
#src__=1,
)
#return subject_list
#return map(lambda x:(x.subject, x.reference), subject_list)
# Convert the result into list
# This is not the fastest approach but should be OK for
# moderate size
subject_list = list(subject_list)
subject_count = len(
subject_list) # Not the fastest (use countResults instead)
# Return immediately if empty
if not subject_count:
return '<p></p>'
# Now build the page
result = []
last_subject = None
for subject in subject_list:
if last_subject != subject.subject:
subject_title = subject.subject
subject_title = subject_title[0].upper() + subject_title[1:]
result.append("<h1>%s</h1>" % subject_title)
result.append("""<p><a href="%s/%s/view">%s</a></p>""" %
(web_section_url, subject.reference, subject.title))
last_subject = subject.subject
return '\n'.join(result)
def afterSetUp(self):
domain_tool = self.getDomainTool()
# Query to restrict searches to 'interesting' predicates:
# - ignore simulation rules, which are now predicates
# - ignore as well constraints, which are predicates
self.portal_type_query = Query(
operator='AND',
portal_type=[
'!=%s' % x for x in domain_tool.getPortalRuleTypeList() +
('Base Domain', 'Contribution Predicate') +
domain_tool.getPortalConstraintTypeList()
])
super(TestDomainTool, self).afterSetUp()
def getUnreadDocumentUrlList(self, portal_type=None, user_name=None, **kw):
"""
returns document that needs to be acknowledged :
- Acknowledgement (internal email)
- Site Message
This method will mainly be used by getUnreadAcknowledgementList. Also,
because url are used, the result will be easy to cache.
"""
document_list = []
if user_name is not None:
portal = self.getPortalObject()
person_value = portal.ERP5Site_getAuthenticatedMemberPersonValue(
user_name=user_name)
if person_value is not None:
now = DateTime()
# First look at all event that define the current user as destination
all_document_list = [x.getObject() for x in \
self.portal_catalog(portal_type = portal_type,
simulation_state = self.getPortalTransitInventoryStateList(),
# start_date = {'query':now,'range':'max'},
# stop_date = {'query':now,'range':'min'},
default_destination_uid=person_value.getUid())]
# Now we can look directly at acknowledgement document not approved yet
# so not in a final state
final_state_list = self.getPortalCurrentInventoryStateList()
query = NegatedQuery(Query(simulation_state=final_state_list))
for x in self.portal_catalog(
portal_type=self._getAcknowledgementTypeList(),
query=query,
# start_date = {'query':now,'range':'max'},
# stop_date = {'query':now,'range':'min'},
default_destination_uid=person_value.getUid()):
x = x.getObject()
if x not in all_document_list:
all_document_list.append(x)
for document in all_document_list:
# We filter manually on dates until a good solution is found for
# searching by dates on the catalog
if (document.getStartDate() < now <
(document.getStopDate() + 1)):
acknowledged = document.isAcknowledged(
user_name=user_name)
if not acknowledged:
document_list.append(document.getRelativeUrl())
else:
raise ValueError('No user name given')
return document_list
def afterSetUp(self):
domain_tool = self.getDomainTool()
# Query to restrict searches to 'interesting' predicates:
# - ignore simulation rules, which are now predicates
# - ignore as well constraints, which are predicates
self.portal_type_query = Query(
operator='AND',
portal_type=[
'!=%s' % x for x in domain_tool.getPortalRuleTypeList() +
('Base Domain', 'Contribution Predicate', 'Solver Type',
'Trade Model Path', 'Worklist') +
domain_tool.getPortalDivergenceTesterTypeList() +
domain_tool.getPortalBusinessProcessTypeList() +
domain_tool.getPortalBusinessLinkTypeList() +
domain_tool.getPortalConstraintTypeList()
])
super(TestDomainTool, self).afterSetUp()
def isVersionUnique(self):
"""
Returns true if no other document exists with the same
reference, version and language, or if the current
document has no reference.
"""
if not self.getReference():
return True
kw = dict(portal_type=self.getPortalDocumentTypeList(),
reference=self.getReference(),
version=self.getVersion(),
language=self.getLanguage(),
query=NegatedQuery(Query(validation_state=('cancelled', 'deleted'))))
catalog = self.getPortalObject().portal_catalog
self_count = catalog.unrestrictedCountResults(uid=self.getUid(), **kw)[0][0]
count = catalog.unrestrictedCountResults(**kw)[0][0]
# If self is not indexed yet, then if count == 1, version is not unique
return count <= self_count
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()
# compute sql params, we group and order by date and portal type
if aggregation_level == "year":
sql_format = "%Y"
elif aggregation_level == "month":
sql_format = "%Y-%m"
elif aggregation_level == "week":
sql_format = "%Y-%u"
elif aggregation_level == "day":
sql_format = "%Y-%m-%d"
if to_date is not None:
to_date = atTheEndOfPeriod(to_date, period=aggregation_level)
params = {"creation_date":(from_date, to_date)}
query=None
if from_date is not None and to_date is not None:
params = {"creation_date":(from_date, to_date)}
query = Query(range="minmax", **params)
elif from_date is not None:
params = {"creation_date":from_date}
query = Query(range="min", **params)
elif to_date is not None:
params = {"creation_date":to_date}
query = Query(range="max", **params)
select_expression = {'date' : 'DATE_FORMAT(creation_date, "%s")'%sql_format, 'portal_type' : None}
group_by = ['DATE_FORMAT(creation_date, "%s")' % sql_format, 'portal_type']
# count number of object created by the user for each type of document
reference = kw.get('person_reference_list', context.getReference())
result_list = context.portal_catalog.countResults(select_expression=select_expression,
portal_type=portal_type_list,limit=None,
owner=reference,query=query,
group_by_expression=group_by)
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
mirror_section = mirror_section or request.get('mirror_section')
if mirror_section:
search_kw['mirror_section_uid'] = portal.restrictedTraverse(
mirror_section).getUid()
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.
"""Cleanup the data from support request module.
So that test are isolated.
"""
from Products.ZSQLCatalog.SQLCatalog import Query, NegatedQuery
portal = context.getPortalObject()
test_project_set = set(
(portal.project_module.erp5_officejs_support_request_ui_test_project_001,
portal.project_module.erp5_officejs_support_request_ui_test_project_002))
to_delete_list = []
for brain in portal.portal_catalog(
portal_type="Support Request",
simulation_state=NegatedQuery(
Query(simulation_state=("cancelled", )))):
support_request = brain.getObject()
if support_request.getId().startswith(
'erp5_officejs_support_request_ui_test_'):
continue # business template data
assert support_request.getSourceProjectValue() in test_project_set, \
"Support request %s have unexpected project." % support_request.absolute_url()
to_delete_list.append(support_request.getId())
portal.support_request_module.manage_delObjects(to_delete_list)
event_to_delete_id_list = []
for event in portal.event_module.contentValues():
if event.getFollowUp(portal_type='Support Request'):
event_to_delete_id_list.append(event.getId())
portal.event_module.manage_delObjects(event_to_delete_id_list)
# Clear worklist cache
portal_categories = portal.portal_categories
now = DateTime()
effective_date = context.getEffectiveDate()
previous_pay_day = addToDate(effective_date, month=-1)
# Get period dates
result = portal.portal_catalog(portal_type="DSN Monthly Report",
simulation_state="validated",
sort_on=[("creation_date", "descending")])
from_date = DateTime(effective_date.year(), effective_date.month(), 1)
# We report leave periods which are not over yet ...
result = portal.portal_catalog(portal_type='Leave Request Period',
query=Query(expiration_date=None))
leave_period_list = [period.getObject() for period in result]
# ... And leave periods which ended during last period
result = portal.portal_catalog(portal_type='Leave Request Period',
expiration_date=">=%s" %
from_date.strftime("%Y/%m"))
# We need to filter results, because we can't search in a date interval with
# a smaller grain than a month.
leave_period_list.extend([
period.getObject() for period in result
if period.getExpirationDate() > from_date
])
def formatDate(datetime):
from Products.ZSQLCatalog.SQLCatalog import Query
from erp5.component.module.DateUtils import addToDate
from DateTime import DateTime
portal = context.getPortalObject()
portal.portal_catalog.searchAndActivate(
portal_type="Leave Request",
method_id='LeaveRequest_createRepresentativeRecord',
creation_date = Query(creation_date=addToDate(DateTime(), to_add={'day': -90}), range="min"),
activate_kw={'tag': tag},
)
context.activate(after_tag=tag).getId()
currency = portal.Base_getCurrencyForSection(request['section_category'])
precision = portal.account_module.getQuantityPrecisionFromResource(currency)
request.set('precision', precision)
# There are some disabled fields in Account_viewAccountingTransactionList based on this condition.
request.other['is_accounting_report'] = True
params = dict(
precision=precision,
section_uid=section_uid,
simulation_state=simulation_state,
)
project = request.get('project')
if project:
if project == 'None':
params['project_uid'] = Query(project_uid=None)
else:
params['project_uid'] = portal.portal_categories.restrictedTraverse(
project).getUid()
funding_category = request.get('funding')
if funding_category:
if funding_category == 'None':
params['funding_uid'] = Query(funding_uid=None)
else:
funding_value = portal.restrictedTraverse(funding_category, None)
if funding_value is not None and funding_value.getPortalType(
) != 'Category':
params['funding_uid'] = funding_value.getUid()
else:
params['funding_category'] = funding_category
portal_preferences = portal.portal_preferences
if not portal_preferences.isAuthenticationPolicyEnabled() or \
not portal_preferences.isPreferredSystemRecoverExpiredPassword():
# no policy, no sense to file expire at all or symply system do not configured to
return
user = context.getParentValue()
username = context.getReference()
# Prevent creating new recovery if one was recently created
recovery_list = portal.portal_catalog(
portal_type="Credential Recovery",
reference=username,
default_destination_decision_uid=user.getUid(),
creation_date=Query(range="min",
creation_date=addToDate(DateTime(), {'day': -1})),
limit=1)
if recovery_list:
return
tag = 'credential_recovery_%s' % context.getReference()
if portal.portal_activities.countMessageWithTag(tag):
return
module = portal.getDefaultModule(portal_type='Credential Recovery')
credential_recovery = module.newContent(
portal_type="Credential Recovery",
reference=username,
destination_decision_value=user,
language=portal.Localizer.get_selected_language(),
activate_kw={'tag': tag})
context.serialize()
from zExceptions import NotFound
from Products.ZSQLCatalog.SQLCatalog import ComplexQuery
from Products.ZSQLCatalog.SQLCatalog import Query
now = DateTime()
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
"""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 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()
params['ledger'] = kw['ledger']
category_uid_list = ('payment_uid', 'project_uid', 'funding_uid', 'function_uid',
'ledger_uid', 'payment_request_uid', 'default_aggregate_uid')
for category_uid in category_uid_list:
category_uid_value = kw.get(category_uid)
if category_uid_value:
if category_uid_value == 'None':
# XXX Jerome: this code needs some clarification. It is used after a dialog
# with a list field for project (same for function, payment_request,
# funding) where the user can select an empty item which means no filter
# on project, can select a project which means only transactions for
# that specific project, or select a special value "None" which means
# transactions that are not related to a project. For that we need a
# query that will be translated as stock.project_uid IS NULL.
params[category_uid] = Query(**{category_uid: None})
else:
params[category_uid] = category_uid_value
funding_category = kw.get('funding_category')
if funding_category:
if funding_category == 'None':
params['funding_uid'] = Query(funding_uid=None)
else:
params['funding_category'] = funding_category
function_category = kw.get('function_category')
if function_category:
if function_category == 'None':
params['function_uid'] = Query(function_uid=None)
else:
params['function_category'] = function_category
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')
def mergeRevision(self):
"""
Merge the current document with any previous revision
or change its version to make sure it is still unique.
NOTE: revision support is implemented in the Document
class rather than within the ContributionTool
because the ingestion process requires to analyse the content
of the document first. Hence, it is not possible to
do any kind of update operation until the whole ingestion
process is completed, since update requires to know
reference, version, language, etc. In addition,
we have chosen to try to merge revisions after each
metadata discovery as a way to make sure that any
content added in the system through the ContributionTool
(ex. through webdav) will be merged if necessary.
It may be posssible though to split disoverMetadata and
finishIngestion.
"""
document = self
if self.getReference():
invalid_validation_state_list = ('archived', 'cancelled',
'deleted')
catalog = self.getPortalObject().portal_catalog
# Find all document with same (reference, version, language)
kw = dict(
portal_type=self.getPortalType(),
reference=self.getReference(),
query=NegatedQuery(
Query(validation_state=invalid_validation_state_list)),
sort_on='creation_date')
if self.getVersion():
kw['version'] = self.getVersion()
if self.getLanguage():
kw['language'] = self.getLanguage()
document_list = catalog.unrestrictedSearchResults(**kw)
existing_document = None
# Select the first one which is not self and which
# shares the same coordinates
for o in document_list:
if o.getRelativeUrl() != self.getRelativeUrl() and\
o.getVersion() == self.getVersion() and\
o.getLanguage() == self.getLanguage():
existing_document = o.getObject()
if existing_document.getValidationState() not in \
invalid_validation_state_list:
break
else:
existing_document = None
# We found an existing document to update
if existing_document is not None:
document = existing_document
if not _checkPermission(Permissions.ModifyPortalContent,
existing_document):
raise Unauthorized(
"[DMS] You are not allowed to update the existing document which has the same coordinates (id %s)"
% existing_document.getId())
else:
update_kw = {}
for k in self.propertyIds():
if k not in FIXED_PROPERTY_IDS and self.hasProperty(k):
update_kw[k] = self.getProperty(k)
existing_document.edit(**update_kw)
# Erase self
self.getParentValue().manage_delObjects([
self.getId(),
])
return document
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)
portal_preferences = portal.portal_preferences
blocked_user_login_list = []
all_blocked_user_login_dict = {}
now = DateTime()
one_second = 1 / 24.0 / 60.0 / 60.0
check_duration = portal_preferences.getPreferredAuthenticationFailureCheckDuration(
)
max_authentication_failures = portal_preferences.getPreferredMaxAuthenticationFailure(
)
check_time = now - check_duration * one_second
kw = {
'portal_type': 'Authentication Event',
'creation_date': Query(creation_date=check_time, range='min'),
'validation_state': 'confirmed'
}
failure_list = portal.portal_catalog(**kw)
for failure in failure_list:
person = failure.getDestinationValue()
if person not in all_blocked_user_login_dict.keys():
all_blocked_user_login_dict[person] = []
all_blocked_user_login_dict[person].append(failure)
# leave only ones that are blocked:
for person, failure_list in all_blocked_user_login_dict.items():
if len(failure_list) >= max_authentication_failures:
blocked_user_login_list.append(
newTempBase(
portal, person.getTitle(), **{
source_project_uid_list = [
x.uid for x in context.portal_catalog(relative_url='%s/%%' %
context.getRelativeUrl())
] + [context.getUid()]
from Products.ZSQLCatalog.SQLCatalog import Query
sql_kw = {}
if kw.has_key('from_date') and kw['from_date'] is not None:
query_kw = {'delivery.start_date': kw['from_date'], 'range': 'min'}
sql_kw['delivery.start_date'] = Query(**query_kw)
if kw.has_key('at_date') and kw['at_date'] is not None:
query_kw = {'delivery.stop_date': kw['at_date'], 'range': 'ngt'}
sql_kw['delivery.stop_date'] = Query(**query_kw)
# Make sure to not include "confirmed tasks" in any case, because in
# this case we must take task reports
if kw.has_key('simulation_state') and len(kw['simulation_state']) > 0:
task_simulation_state = [
x for x in kw['simulation_state'] if x != 'confirmed'
]
task_report_simulation_state = kw['simulation_state']
else:
task_simulation_state = context.getPortalDraftOrderStateList() + \
context.getPortalPlannedOrderStateList()
task_report_simulation_state = ""
task_list = [x.getObject() for x in \
context.portal_catalog(selection_report=selection_report,
portal_type='Task',
source_project_uid = source_project_uid_list,
params = portal.ERP5Site_getAccountingSelectionParameterDict(selection_name)
# this also prevents to be called directly
assert 'node_uid' in kw
total_debit = 0
total_credit = 0
total_debit_price = 0
total_credit_price = 0
at_date = (from_date - 1).latestTime()
inventory_query = {
'at_date':
at_date, # this is not to_date
'grouping_query':
ComplexQuery(Query(grouping_reference=None),
Query(grouping_date=at_date, range="min"),
logical_operator="OR"),
'simulation_state':
params['simulation_state'],
'node_uid':
kw['node_uid'],
'portal_type':
portal.getPortalAccountingMovementTypeList(),
'section_uid':
params['section_uid'],
'sort_on': (
('stock.date', 'ASC'),
('stock.uid', 'ASC'),
)
}
# merchant_registry for merchants.
# 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.
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 DateTime import DateTime
from Products.ZSQLCatalog.SQLCatalog import AndQuery, OrQuery, Query, NegatedQuery, SimpleQuery
portal = context.getPortalObject()
portal_catalog = portal.portal_catalog
now = DateTime()
query = AndQuery(
Query(portal_type=["Data Ingestion Line", "Data Analysis Line"]),
Query(**{"stock.quantity": "!=0"}),
Query(resource_portal_type="Data Product"),
# Should be improved to support mor than one analysis per ingestion
#SimpleQuery(parent_causality_related_relative_url = None),
OrQuery(
Query(simulation_state="stopped",
use_relative_url="use/big_data/ingestion/batch"),
AndQuery(Query(simulation_state="started"),
Query(use_relative_url="use/big_data/ingestion/stream"))))
for movement in portal_catalog(query):
if movement.getQuantity() <= 0:
continue
if movement.DataIngestionLine_hasMissingRequiredItem():
raise ValueError("Transformation requires movement to have " +
"aggregated data ingestion batch")
data_ingestion = movement.getParentValue()
# Get applicable transformation
for transformation in portal_catalog(
portal_type="Data Transformation",
validation_state="validated",
