def _query(self, **kw):
principal = common.get_request_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
results.extend(query.all())
for obj_role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS:
object_roles_domain_status = self.item_status_filter(
kw, [obj_role])
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
prm = IPrincipalRoleMap(obj)
if (prm.getSetting(obj_role, principal.id) == Allow):
results.append(
contained(obj, self, self.string_key(obj)))
results = [
item for item in results
if checkPermission(view_permission(item),
contained(item, self, self.string_key(item)))
]
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=reverse)
count = len(results)
if not (kw.get("filter_title", None) or kw.get("filter_type", None)
or kw.get("filter_status", None)
or kw.get("filter_status_date", None)):
self.set_tab_count(principal.id, count)
return (results, count)
def _query(self, **kw):
principal = utils.get_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
results.extend(query.all())
for obj_role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS:
object_roles_domain_status = self.item_status_filter(
kw, [obj_role])
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
prm = IPrincipalRoleMap(obj)
if (prm.getSetting(obj_role, principal.id) == Allow):
results.append(
contained(obj, self, self.string_key(obj)))
results = [item for item in results if checkPermission(
view_permission(item), contained(item, self, self.string_key(item)))]
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=reverse)
count = len(results)
if not (kw.get("filter_title", None) or
kw.get("filter_type", None) or
kw.get("filter_status", None) or
kw.get("filter_status_date", None)
):
self.set_tab_count(principal.id, count)
return (results, count)
def get_batch(self, start, limit):
"""Get the data instances for this batch.
"""
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query,
self.domain_model)
# other filters
query = self.query_add_filters(query, self.getFilter())
# order_by
order_by = self.getSort() # [sort_on_expressions]
if order_by:
query = query.order_by(order_by)
# get total number of items before applying an offset and limit
self.set_size = query.count()
# offset and limit
query = query.offset(start).limit(limit)
# bungeni.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
return [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context, self.permission)
]
def get_batch(self, start=0, limit=25, lang=None):
context = removeSecurityProxy(self.context)
filter_title = self.request.get("filter_title", None)
filter_type = self.request.get("filter_type", None)
filter_status = self.request.get("filter_status", None)
filter_status_date = self.request.get("filter_status_date", "")
filter_group = self.request.get("filter_group", "")
results, self.set_size = context.query(
filter_title=filter_title,
filter_type=filter_type,
filter_status=filter_status,
filter_status_date=filter_status_date,
filter_group=filter_group,
sort_on=self.sort_on,
sort_dir=self.sort_dir,
start=start,
limit=limit,
)
results = [
contained(ob, self, context.string_key(ob)) for ob in results
]
nodes = results[start:start + limit]
nodes = self.translate_objects(nodes, lang)
batch = self._json_values(nodes)
return batch
def getBatch(self, start=0, limit=20, lang=None):
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query,
self.domain_model)
# other filters
query = self.query_add_filters(query, self.getFilter())
# order_by
order_by = self.getSort() # [sort_on_expressions]
if order_by:
query = query.order_by(order_by)
# ore.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
nodes = [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context, self.permission)
]
self.set_size = len(nodes)
nodes[:] = nodes[start:start + limit]
nodes = self.translate_objects(nodes, lang)
batch = self._jsonValues(nodes, self.fields)
return batch
def getBatch(self, start=0, limit=20, lang=None):
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query, self.domain_model)
# other filters
query = self.query_add_filters(query, self.getFilter())
# order_by
order_by = self.getSort() # [sort_on_expressions]
if order_by:
query = query.order_by(order_by)
# ore.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
nodes = [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context, self.permission)
]
self.set_size = len(nodes)
nodes[:] = nodes[start : start + limit]
nodes = self.translate_objects(nodes, lang)
batch = self._jsonValues(nodes, self.fields)
return batch
def get_batch(self, start, limit):
"""Get the data instances for this batch.
"""
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query,
self.domain_model)
# other filters
query = self.query_add_filters(query, self.getFilter())
# order_by
order_by = self.getSort() # [sort_on_expressions]
if order_by:
query = query.order_by(order_by)
# get total number of items before applying an offset and limit
self.set_size = query.count()
# offset and limit
query = query.offset(start).limit(limit)
# bungeni.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
return [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context, self.permission)
]
def get(self, name, default=None):
try:
domain_class, principal_name = self.value_key(name)
except ValueError:
return default
session = Session()
try:
value = session.query(domain_class).filter(domain_class.principal_name == principal_name).one()
except orm.exc.NoResultFound:
return default
return contained(value, self, name)
def get(self, name, default=None):
try:
domain_class, group_principal_id = self.value_key(name)
except ValueError:
return default
session = Session()
try:
value = session.query(domain_class).filter(
domain_class.group_principal_id == group_principal_id).one()
except orm.exc.NoResultFound:
return default
return contained(value, self, name)
def get(self, name, default=None):
try:
domain_class, principal_name = self.value_key(name)
except ValueError:
return default
query = Session().query(domain_class).filter(
domain_class.principal_name == principal_name)
try:
value = query.one()
except orm.exc.NoResultFound:
return default
return contained(value, self, name)
def get(self, name, default=None):
try:
domain_class, primary_key = valueKey(name)
except:
return default
session = Session()
value = session.query(domain_class).get(primary_key)
if value is None:
return default
# The check below is to ensure an error is raised if an object is not
# in the tab requested eg. through an outdated url
if self.check_item(domain_class, value.status):
value = contained(value, self, name)
return value
else:
return default
def get_batch(self, start, limit):
"""Get the data instances for this batch.
"""
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query,
self.domain_model)
sort_on_expressions = []
# other filters
lc_filter_queries = self.get_filter()
sort_on_keys = self.get_sort_keys()
if sort_on_keys:
for sort_on in sort_on_keys:
md_field = self.domain_annotation.get(sort_on)
if md_field:
if not md_field.listing_column_filter:
pass
#continue
#!+SORTING(mb, Mar-2013) why does sorting need a filter?
else:
# check domain model if this if field is not in descriptor
if not hasattr(self.domain_model, sort_on):
continue
sort_on_expressions.append(
self.sort_dir_func(
getattr(self.domain_model, sort_on)))
for lc_filter_query, params in lc_filter_queries:
filter_string = params[0]
column_name = params[1]
query = lc_filter_query(query, filter_string, self.sort_dir_func, column_name)
if sort_on_expressions:
query = query.order_by(*sort_on_expressions)
#add optional filters, used by sub classes
query = self.query_add_filters(query)
# get total number of items before applying an offset and limit
self.set_size = query.count()
# offset and limit
query = query.offset(start).limit(limit)
# bungeni.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
# !+STRING_KEY_FILE_VERSION + no permission "bungeni.attachment_version.View"!
return [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context)
]
def get_batch(self, start, limit):
"""Get the data instances for this batch.
"""
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query,
self.domain_model)
sort_on_expressions = []
# other filters
lc_filter_queries = self.get_filter()
sort_on_keys = self.get_sort_keys()
if sort_on_keys:
for sort_on in sort_on_keys:
md_field = self.domain_annotation.get(sort_on)
if md_field:
if not md_field.listing_column_filter:
pass
#continue
#!+SORTING(mb, Mar-2013) why does sorting need a filter?
else:
# check domain model if this if field is not in descriptor
if not hasattr(self.domain_model, sort_on):
continue
sort_on_expressions.append(
self.sort_dir_func(getattr(self.domain_model, sort_on)))
for lc_filter_query, params in lc_filter_queries:
filter_string = params[0]
column_name = params[1]
query = lc_filter_query(query, filter_string, self.sort_dir_func,
column_name)
if sort_on_expressions:
query = query.order_by(*sort_on_expressions)
#add optional filters, used by sub classes
query = self.query_add_filters(query)
# get total number of items before applying an offset and limit
self.set_size = query.count()
# offset and limit
query = query.offset(start).limit(limit)
# bungeni.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
# !+STRING_KEY_FILE_VERSION + no permission "bungeni.attachment_version.View"!
return [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context)
]
def extend_results_for_roles(roles):
domain_status = self.item_status_filter(kw, roles)
OBJECT_ROLES = [
role for role in roles if role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS ]
for domain_class, status in domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
query = self.filter_group(query, domain_class, kw)
query = self.filter_title(query, domain_class, kw)
query = self.filter_status_date(query, domain_class, kw)
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
if OBJECT_ROLES:
prm = IPrincipalRoleMap(obj)
if not prm.getSetting(obj_role, principal_id) == Allow:
continue
results.append(contained(obj, self, self.string_key(obj)))
def get_batch(self, start=0, limit=25, lang=None):
context = removeSecurityProxy(self.context)
filter_short_title = self.request.get("filter_short_title", None)
filter_type = self.request.get("filter_type", None)
filter_status = self.request.get("filter_status", None)
results, self.set_size = context.query(
filter_short_title=filter_short_title,
filter_type=filter_type,
filter_status=filter_status,
sort_on=self.sort_on,
sort_dir=self.sort_dir,
start=start,
limit=limit,
)
results = [ contained(ob, self, workspace.stringKey(ob))
for ob in results ]
results = self.check_permission(results)
nodes = results[start:start + limit]
nodes = self.translate_objects(nodes, lang)
batch = self._json_values(nodes)
return batch
def extend_results_for_roles(roles):
domain_status = self.item_status_filter(kw, roles)
OBJECT_ROLES = [
role for role in roles
if role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS
]
for domain_class, status in domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
query = self.filter_group(query, domain_class, kw)
query = self.filter_title(query, domain_class, kw)
query = self.filter_status_date(query, domain_class, kw)
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
if OBJECT_ROLES:
prm = IPrincipalRoleMap(obj)
if not prm.getSetting(obj_role, principal_id) == Allow:
continue
results.append(contained(obj, self, self.string_key(obj)))
def get_batch(self, start, limit):
"""Get the data instances for this batch.
"""
context = proxy.removeSecurityProxy(self.context)
query = context._query
# date_range filter (try from: model, then cookie, then request)
query = query_filter_date_range(context, self.request, query,
self.domain_model)
sort_on_expressions = []
# other filters
filter_string, lc_filter_queries = self.get_filter()
query = self.query_add_filters(query, filter_string)
sort_on_keys = self.get_sort_keys()
if sort_on_keys:
for sort_on in sort_on_keys:
md_field = self.domain_annotation.get(sort_on)
if md_field:
lc_filter = md_field.listing_column_filter
if not lc_filter:
sort_on_expressions.append(
self.sort_dir_func(
getattr(self.domain_model, sort_on)))
for lc_filter_query, lc_filter_string in lc_filter_queries:
query = lc_filter_query(query, lc_filter_string, self.sort_dir_func)
if sort_on_expressions:
query = query.order_by(sort_on_expressions)
# get total number of items before applying an offset and limit
self.set_size = query.count()
# offset and limit
query = query.offset(start).limit(limit)
# bungeni.alchemist.container.AlchemistContainer.batch()
# nodes: [<bungeni.models.domain.Question]
return [
container.contained(ob, self, container.stringKey(ob))
for ob in query_iterator(query, self.context, self.permission)
]
def get_batch(self, start=0, limit=25, lang=None):
context = removeSecurityProxy(self.context)
filter_title = self.request.get("filter_title", None)
filter_type = self.request.get("filter_type", None)
filter_status = self.request.get("filter_status", None)
filter_status_date = self.request.get("filter_status_date", "")
filter_group = self.request.get("filter_group", "")
results, self.set_size = context.query(
filter_title=filter_title,
filter_type=filter_type,
filter_status=filter_status,
filter_status_date=filter_status_date,
filter_group=filter_group,
sort_on=self.sort_on,
sort_dir=self.sort_dir,
start=start,
limit=limit,
)
results = [ contained(ob, self, context.string_key(ob))
for ob in results ]
nodes = results[start:start + limit]
nodes = self.translate_objects(nodes, lang)
batch = self._json_values(nodes)
return batch
def items(self, **kw):
for obj in self._query(kw):
name = stringKey(obj)
yield (name, contained(obj, self, name))
