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(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 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 items(self, **kw): for obj in self._query(kw): name = stringKey(obj) yield (name, contained(obj, self, name))