def get_query_set(self, request=None):
# First, we collect all the declared list filters.
qs = self.root_query_set.clone()
try:
(self.filter_specs, self.has_filters, remaining_lookup_params,
use_distinct) = self.get_filters(request)
# Then, we let every list filter modify the queryset to its liking.
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
except ValueError:
# Django < 1.4.
remaining_lookup_params = self._lookup_param_1_3()
try:
# Finally, we apply the remaining lookup parameters from the query
# string (i.e. those that haven't already been processed by the
# filters).
qs = qs.filter(**remaining_lookup_params)
# TODO: This should probably be mongoengine exceptions
except (SuspiciousOperation, ImproperlyConfigured):
# Allow certain types of errors to be re-raised as-is so that the
# caller can treat them in a special way.
raise
except Exception, e:
# Every other error is caught with a naked except, because we don't
# have any other way of validating lookup parameters. They might be
# invalid if the keyword arguments are incorrect, or if the values
# are not in the correct type, so we might get FieldError,
# ValueError, ValidationError, or ?.
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
try:
return queryset.filter(**self.used_parameters)
except (ValueError, ValidationError) as e:
# Fields may raise a ValueError or ValidationError when converting
# the parameters to the correct type.
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
status = self.used_parameters.get(self.parameter_name)
if status in Credit.STATUS_LOOKUP:
try:
return queryset.filter(Credit.STATUS_LOOKUP[status])
except ValidationError as e:
raise IncorrectLookupParameters(e)
def get_query_set(self, request):
lookup_params, use_distinct = self.get_lookup_params(
use_distinct=False)
self.filter_specs, self.has_filters = self.get_filters(
request, use_distinct)
try:
# First, let every list filter modify the qs and params to its
# liking.
qs = self.root_query_set
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
for param in filter_spec.used_params():
try:
del lookup_params[param]
except KeyError:
pass
# Then, apply the remaining lookup parameters from the query string
# (i.e. those that haven't already been processed by the filters).
qs = qs.filter(**lookup_params)
except Exception, e:
# Naked except! Because we don't have any other way of validating
# "lookup_params". They might be invalid if the keyword arguments
# are incorrect, or if the values are not in the correct type, so
# we might get FieldError, ValueError, ValicationError, or ? from a
# custom field that raises yet something else when handed
# impossible data.
raise IncorrectLookupParameters(e)
def _get_descendants(self, request, root_id):
try:
root = self.field.rel.to.objects.get(pk=root_id)
except self.field.rel.to.DoesNotExist:
_add_incorrect_value_message(request, self.title)
raise IncorrectLookupParameters()
return root.get_descendants(include_self=True)
def queryset(self, request, queryset):
_filter = dict((p, bitor(F(p), v))
for p, v in six.iteritems(self.used_parameters))
try:
return queryset.filter(**_filter)
except ValidationError as e:
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
try:
if not self.used_parameters:
return queryset.filter(location='interior')
return queryset.filter(**self.used_parameters)
except (ValueError, ValidationError) as e:
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
if self.value() is None or self.value() == '1':
return queryset.filter(draft=bool(self.value()))
if self.value() == 'all':
return queryset.all()
raise IncorrectLookupParameters()
def queryset(self, request, queryset):
value = self.value()
if not value:
ids = []
else:
ids = value.split(',')
q_param = Q()
for id_ in ids:
if id_ == self.empty_value:
q_param |= Q(**{'{}__isnull'.format(self.field_path): True})
else:
q_param |= Q(
**{
'{}__in'.format(self.field_path):
self._get_descendants(request, id_)
})
try:
queryset = queryset.filter(q_param)
except ValueError:
messages.warning(
request,
_('Incorrect value in "%(field_name)s" filter') %
{'field_name': self.title})
raise IncorrectLookupParameters()
return queryset
def get_query_set(self, request):
MULTI_SEARCH_VAR = []
for var, label, query in self.model_admin.multi_search:
MULTI_SEARCH_VAR.append(var)
# First, we collect all the declared list filters.
(self.filter_specs, self.has_filters, remaining_lookup_params,
use_distinct) = self.get_filters(request)
# Then, we let every list filter modify the queryset to its liking.
qs = self.root_query_set
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
try:
# Finally, we apply the remaining lookup parameters from the query
# string (i.e. those that haven't already been processed by the
# filters).
qs = qs.filter(**remaining_lookup_params)
except (SuspiciousOperation, ImproperlyConfigured):
# Allow certain types of errors to be re-raised as-is so that the
# caller can treat them in a special way.
raise
except Exception, e:
# Every other error is caught with a naked except, because we don't
# have any other way of validating lookup parameters. They might be
# invalid if the keyword arguments are incorrect, or if the values
# are not in the correct type, so we might get FieldError,
# ValueError, ValidationError, or ?.
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
filter = dict(
(p, F(p) | v) for p, v in self.used_parameters.iteritems())
try:
return queryset.filter(**filter)
except ValidationError, e:
raise IncorrectLookupParameters(e)
def filter_tree_queryset(self, queryset, request):
change_list = self.get_change_list_for_tree(request)
self.filter_specs, self.has_filters, remaining_lookup_params, filters_use_distinct = change_list.get_filters(
request)
# Then, we let every list filter modify the queryset to its liking.
qs = queryset
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
try:
# Finally, we apply the remaining lookup parameters from the query
# string (i.e. those that haven't already been processed by the
# filters).
qs = qs.filter(**remaining_lookup_params)
except (SuspiciousOperation, ImproperlyConfigured):
# Allow certain types of errors to be re-raised as-is so that the
# caller can treat them in a special way.
raise
except Exception as e:
# Every other error is caught with a naked except, because we don't
# have any other way of validating lookup parameters. They might be
# invalid if the keyword arguments are incorrect, or if the values
# are not in the correct type, so we might get FieldError,
# ValueError, ValidationError, or ?.
raise IncorrectLookupParameters(e)
return qs
def get_queryset(self, request):
# First, we collect all the declared list filters.
(self.filter_specs, self.has_filters, remaining_lookup_params,
filters_use_distinct) = self.get_filters(request)
# Then, we let every list filter modify the queryset to its liking.
qs = self.root_queryset
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
try:
# Finally, we apply the remaining lookup parameters from the query
# string (i.e. those that haven't already been processed by the
# filters).
qs = qs.filter(**remaining_lookup_params)
except (SuspiciousOperation, ImproperlyConfigured):
# Allow certain types of errors to be re-raised as-is so that the
# caller can treat them in a special way.
raise
except Exception as e:
# Every other error is caught with a naked except, because we don't
# have any other way of validating lookup parameters. They might be
# invalid if the keyword arguments are incorrect, or if the values
# are not in the correct type, so we might get FieldError,
# ValueError, ValidationError, or ?.
raise IncorrectLookupParameters(e)
# Use select_related() if one of the list_display options is a field
# with a relationship and the provided queryset doesn't already have
# select_related defined.
if not qs.query.select_related:
if self.list_select_related:
qs = qs.select_related()
else:
for field_name in self.list_display:
try:
field = self.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
pass
else:
if isinstance(field.rel, models.ManyToOneRel):
qs = qs.select_related()
break
# Set ordering.
ordering = self.get_ordering(request, qs)
qs = qs.order_by(*ordering)
# Apply search results
qs, search_use_distinct = self.model_admin.get_search_results(
request, qs, self.query)
# Remove duplicates from results, if neccesary
if filters_use_distinct | search_use_distinct:
return qs.distinct()
else:
return qs
def get_query_set(self, request=None):
# First, we collect all the declared list filters.
qs = self.root_query_set.clone()
try:
(self.filter_specs, self.has_filters, remaining_lookup_params,
use_distinct) = self.get_filters(request)
# Then, we let every list filter modify the queryset to its liking.
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
except ValueError:
# Django < 1.4.
remaining_lookup_params = self._lookup_param_1_3()
try:
# Finally, we apply the remaining lookup parameters from the query
# string (i.e. those that haven't already been processed by the
# filters).
qs = qs.filter(**remaining_lookup_params)
# TODO: This should probably be mongoengine exceptions
except (SuspiciousOperation, ImproperlyConfigured):
# Allow certain types of errors to be re-raised as-is so that the
# caller can treat them in a special way.
raise
except Exception as e:
# Every other error is caught with a naked except, because we don't
# have any other way of validating lookup parameters. They might be
# invalid if the keyword arguments are incorrect, or if the values
# are not in the correct type, so we might get FieldError,
# ValueError, ValidationError, or ?.
raise IncorrectLookupParameters(e)
# Set ordering.
ordering = self.get_ordering(request, qs)
qs = qs.order_by(*ordering)
# Apply keyword searches.
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
# No __search for mongoengine
#elif field_name.startswith('@'):
# return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
if self.search_fields and self.query:
orm_lookups = [construct_search(str(search_field))
for search_field in self.search_fields]
for bit in self.query.split():
or_queries = [Q(**{orm_lookup: bit})
for orm_lookup in orm_lookups]
qs = qs.filter(reduce(operator.or_, or_queries))
return qs
def get_filters(self, request):
lookup_params = self.get_filters_params()
use_distinct = False
for key, value in lookup_params.items():
if not self.model_admin.lookup_allowed(key, value):
raise DisallowedModelAdminLookup(
"Filtering by %s not allowed" % key)
filter_specs = []
if self.list_filter:
for list_filter in self.list_filter:
if callable(list_filter):
# This is simply a custom list filter class.
spec = list_filter(request, lookup_params, self.model,
self.model_admin)
else:
field_path = None
if isinstance(list_filter, (tuple, list)):
# This is a custom FieldListFilter class for a given field.
field, field_list_filter_class = list_filter
else:
# This is simply a field name, so use the default
# FieldListFilter class that has been registered for
# the type of the given field.
field, field_list_filter_class = list_filter, FieldListFilter.create
if not isinstance(field, models.Field):
field_path = field
field = get_fields_from_path(self.model,
field_path)[-1]
spec = field_list_filter_class(field,
request,
lookup_params,
self.model,
self.model_admin,
field_path=field_path)
# Check if we need to use distinct()
use_distinct = (use_distinct or lookup_needs_distinct(
self.lookup_opts, field_path))
if spec and spec.has_output():
filter_specs.append(spec)
# At this point, all the parameters used by the various ListFilters
# have been removed from lookup_params, which now only contains other
# parameters passed via the query string. We now loop through the
# remaining parameters both to ensure that all the parameters are valid
# fields and to determine if at least one of them needs distinct(). If
# the lookup parameters aren't real fields, then bail out.
try:
for key, value in lookup_params.items():
lookup_params[key] = prepare_lookup_value(key, value)
use_distinct = (use_distinct or lookup_needs_distinct(
self.lookup_opts, key))
return filter_specs, bool(
filter_specs), lookup_params, use_distinct
except FieldDoesNotExist as e:
six.reraise(IncorrectLookupParameters,
IncorrectLookupParameters(e),
sys.exc_info()[2])
def queryset(self, request, queryset):
if self.parameter_name in self.used_parameters:
param = self.used_parameters[self.parameter_name]
try:
return queryset.filter(useraccessrestriction__user__pk=param)
except ValidationError as e:
raise IncorrectLookupParameters(e)
return queryset
def queryset(self, request, queryset):
try:
uri_ref = self.used_parameters.pop(self.lookup_kwarg, None)
if uri_ref:
self.used_parameters[self.lookup_kwarg] = URIRef(uri_ref)
return queryset.filter(**self.used_parameters)
except ValidationError as e:
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
if self.value():
try:
node = queryset.model._default_manager.get(pk=self.value())
except (TypeError, ValueError, queryset.model.DoesNotExist):
raise IncorrectLookupParameters()
return queryset.descendants(node, include_self=True)
return queryset
def queryset(self, request, queryset):
try:
# Convert the __notin to a Django ORM .exclude(...)
if self.lookup_kwarg in self.used_parameters and self.lookup_vals:
queryset = queryset.exclude(**{self.field_path+'__in': self.lookup_vals})
return queryset
except ValidationError as e:
raise IncorrectLookupParameters(e)
def get_queryset(self, request):
# First, we collect all the declared list filters.
(
self.filter_specs,
self.has_filters,
remaining_lookup_params,
filters_may_have_duplicates,
self.has_active_filters,
) = self.get_filters(request)
# Then, we let every list filter modify the queryset to its liking.
qs = self.root_queryset
for filter_spec in self.filter_specs:
new_qs = filter_spec.queryset(request, qs)
if new_qs is not None:
qs = new_qs
try:
# Finally, we apply the remaining lookup parameters from the query
# string (i.e. those that haven't already been processed by the
# filters).
qs = qs.filter(**remaining_lookup_params)
except (SuspiciousOperation, ImproperlyConfigured):
# Allow certain types of errors to be re-raised as-is so that the
# caller can treat them in a special way.
raise
except Exception as e:
# Every other error is caught with a naked except, because we don't
# have any other way of validating lookup parameters. They might be
# invalid if the keyword arguments are incorrect, or if the values
# are not in the correct type, so we might get FieldError,
# ValueError, ValidationError, or ?.
raise IncorrectLookupParameters(e)
# Apply search results
qs, search_may_have_duplicates = self.model_admin.get_search_results(
request,
qs,
self.query,
)
# Set query string for clearing all filters.
self.clear_all_filters_qs = self.get_query_string(
new_params=remaining_lookup_params,
remove=self.get_filters_params(),
)
# Remove duplicates from results, if necessary
if filters_may_have_duplicates | search_may_have_duplicates:
qs = qs.filter(pk=OuterRef("pk"))
qs = self.root_queryset.filter(Exists(qs))
# Set ordering.
ordering = self.get_ordering(request, qs)
qs = qs.order_by(*ordering)
if not qs.query.select_related:
qs = self.apply_select_related(qs)
return qs
def queryset(self, request, queryset):
filter_kwargs = dict((p, BitHandler(v, ()))
for p, v in six.iteritems(self.used_parameters))
if not filter_kwargs:
return queryset
try:
return queryset.filter(**filter_kwargs)
except ValidationError as e:
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
if self.used_parameters:
try:
return queryset.filter(**self.used_parameters)
except ValidationError as e:
raise IncorrectLookupParameters(e)
elif 'q' in request.GET:
return queryset
else:
return queryset.filter(folder__isnull=True)
def queryset(self, request, queryset):
params = Q()
for lookup_arg, value in self.used_parameters.items():
params |= Q(**{lookup_arg: value})
try:
return queryset.filter(params)
except (ValueError, ValidationError) as e:
# Fields may raise a ValueError or ValidationError when converting
# the parameters to the correct type.
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
try:
uri_ref = self.used_parameters.pop(self.lookup_kwarg, None)
if uri_ref:
splitted = uri_ref.split("^^^^")
literal = Literal(splitted[0], datatype=URIRef(splitted[1])) if len(splitted)>1 and splitted[1] else Literal(splitted[0])
self.used_parameters[self.lookup_kwarg] = literal
return queryset.filter(**self.used_parameters)
except ValidationError as e:
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
if self.parameter_name in self.used_parameters:
param = self.used_parameters[self.parameter_name]
bool_val = True if param == '1' else False
final_qs_val = {'urlredirect__isnull': bool_val}
try:
return queryset.filter(**final_qs_val)
except ValidationError as e:
raise IncorrectLookupParameters(e)
return queryset
def queryset(self, request, queryset):
if self.parameter_name in self.used_parameters:
param = self.used_parameters[self.parameter_name]
final = 'simpleaccessrestriction__{}'.format(param)
final_qs_val = {final: True}
try:
return queryset.filter(**final_qs_val)
except ValidationError as e:
raise IncorrectLookupParameters(e)
return queryset
def queryset(self, request, queryset):
if self.values():
try:
return queryset.filter(**{f'{self.parameter_name}__in': self.values()})
except (ValueError, ValidationError) as e:
# Fields may raise a ValueError or ValidationError when converting
# the parameters to the correct type.
raise IncorrectLookupParameters(e)
return queryset
def queryset(self, request, queryset):
try:
if self.lookup_kwarg in self.used_parameters:
for lookup in self.used_parameters[self.lookup_kwarg]:
value = {self.lookup_kwarg: lookup}
queryset = queryset.filter(**value)
else:
queryset.filter(**self.used_parameters)
return queryset
except ValidationError as e:
raise IncorrectLookupParameters(e)
def queryset(self, request, queryset):
if self.value():
try:
ipaddress.ip_address(self.value())
except ValueError:
_add_incorrect_value_message(request, self.title)
raise IncorrectLookupParameters()
else:
queryset = queryset.filter(
ethernet_set__ipaddress__address=self.value())
return queryset
def queryset(self, request, queryset):
query = self.get_query(self.value)
if query is None:
return queryset
try:
return queryset.filter(query)
except (ValueError, ValidationError) as e:
# Fields may raise a ValueError or ValidationError when converting
# the parameters to the correct type.
raise IncorrectLookupParameters(e)
