def __init__(self, *args, **kwargs): super(FilterSet, self).__init__(*args, **kwargs) for name, filter_ in six.iteritems(self.filters): if isinstance(filter_, filters.RelatedFilter): # Populate our FilterSet fields with the fields we've stored # in RelatedFilter. filter_.setup_filterset() self.populate_from_filterset(filter_.filterset, filter_, name) # Add an 'isnull' filter to allow checking if the relation is empty. isnull_filter = filters.BooleanFilter( name=("%s%sisnull" % (filter_.name, LOOKUP_SEP))) self.filters['%s%s%s' % (filter_.name, LOOKUP_SEP, 'isnull')] = isnull_filter elif isinstance(filter_, filters.AllLookupsFilter): # Populate our FilterSet fields with all the possible # filters for the AllLookupsFilter field. model = self._meta.model field = get_model_field(model, filter_.name) for lookup_type in self.LOOKUP_TYPES: if isinstance(field, RelatedObject): f = self.filter_for_reverse_field(field, filter_.name) else: f = self.filter_for_field(field, filter_.name) f.lookup_type = lookup_type f = self.fix_filter_field(f) self.filters["%s%s%s" % (name, LOOKUP_SEP, lookup_type)] = f
def __init__(self, *args, **kwargs): super(FilterSet, self).__init__(*args, **kwargs) for name, filter_ in six.iteritems(self.filters): if isinstance(filter_, filters.RelatedFilter): # Populate our FilterSet fields with the fields we've stored # in RelatedFilter. filter_.setup_filterset() self.populate_from_filterset(filter_.filterset, filter_, name) # Add an 'isnull' filter to allow checking if the relation is empty. isnull_filter = filters.BooleanFilter(name=("%s%sisnull" % (filter_.name, LOOKUP_SEP))) self.filters['%s%s%s' % (filter_.name, LOOKUP_SEP, 'isnull')] = isnull_filter elif isinstance(filter_, filters.AllLookupsFilter): # Populate our FilterSet fields with all the possible # filters for the AllLookupsFilter field. model = self._meta.model field = get_model_field(model, filter_.name) for lookup_type in self.LOOKUP_TYPES: if isinstance(field, RelatedObject): f = self.filter_for_reverse_field(field, filter_.name) else: f = self.filter_for_field(field, filter_.name) f.lookup_type = lookup_type f = self.fix_filter_field(f) self.filters["%s%s%s" % (name, LOOKUP_SEP, lookup_type)] = f
def __new__(cls, name, bases, attrs): new_class = super(FilterSetMetaclass, cls).__new__(cls, name, bases, attrs) # Populate our FilterSet fields with all the possible # filters for the AllLookupsFilter field. for name, filter_ in six.iteritems(new_class.base_filters.copy()): if isinstance(filter_, filters.AllLookupsFilter): model = new_class._meta.model field = filterset.get_model_field(model, filter_.name) for lookup_type in django_filters.filters.LOOKUP_TYPES: if isinstance(field, ForeignObjectRel): f = new_class.filter_for_reverse_field(field, filter_.name) else: f = new_class.filter_for_field(field, filter_.name) f.lookup_type = lookup_type f = new_class.fix_filter_field(f) # compute filter name filter_name = name # Don't add "exact" to filter names if lookup_type != 'exact': filter_name = LOOKUP_SEP.join([name, lookup_type]) new_class.base_filters[filter_name] = f elif name not in new_class.declared_filters: new_class.base_filters[name] = new_class.fix_filter_field(filter_) return new_class
def kitchen_sink_filters_for_model(model, fields=None, exclude=None, filter_for_field=None, filter_for_reverse_field=None): if fields is None: fields = [field.name for field in sorted(model._meta.fields + model._meta.many_to_many) if not isinstance(field, models.AutoField)] # poor-man's inheritance, call the "parent's" method field_dict = filters_for_model(model, fields=fields, exclude=exclude, filter_for_field=filter_for_field, filter_for_reverse_field=filter_for_reverse_field) # This is where the kitchen_sink gets stapled on for field_name in fields: # model._meta.fields: if exclude is not None and field_name in exclude: continue field = get_model_field(model, field_name) if field is None: # field_dict[f] = None continue # Nervous about using hash key lookup instead of isinstance() # The django_types in the dict may be the parents of the intended set of field types for django_type, filter_type in filter_field_type.iteritems(): if isinstance(field, django_type): # FIXME: `filter_suffixes` should be a list within the dict, one for each django_type for suffix in filter_suffixes: # filter_for_field(name...) <-- would be better to use this ?(see filterset use) filter_ = filter_type(name=field.name, lookup_type=suffix) if filter_: field_dict[field_name + '__' + suffix] = filter_ return field_dict
def add_filter(cls, name, filter_=None): field = get_model_field(cls._meta.model, name) if filter_ is None: if isinstance(field, RelatedObject): filter_ = cls.filter_for_reverse_field(field, name) else: filter_ = cls.filter_for_field(field, name) cls.base_filters[name] = filter_
def add_filter(cls, name, filter_=None): field = get_model_field(cls._meta.model, name) if filter_ is None: if isinstance(field, ManyToOneRel): filter_ = cls.filter_for_reverse_field(field, name) else: filter_ = cls.filter_for_field(field, name) cls.base_filters[name] = filter_
def __new__(cls, name, bases, attrs): cls.convert__all__(attrs) new_class = super(FilterSetMetaclass, cls).__new__(cls, name, bases, attrs) fix_filter_field = _get_fix_filter_field(new_class) opts = new_class._meta # order_by is not compatible. if opts.order_by: opts.order_by = False warnings.warn( 'order_by is no longer supported. Use ' 'rest_framework.filters.OrderingFilter instead. See: ' 'https://github.com/philipn/django-rest-framework-filters/issues/72', DeprecationWarning, stacklevel=2 ) # If no model is defined, skip all lookups processing if not opts.model: return new_class # Populate our FilterSet fields with all the possible # filters for the AllLookupsFilter field. for name, filter_ in six.iteritems(new_class.base_filters.copy()): if isinstance(filter_, filters.AllLookupsFilter): field = filterset.get_model_field(opts.model, filter_.name) for lookup_expr in utils.lookups_for_field(field): if isinstance(field, ForeignObjectRel): f = new_class.filter_for_reverse_field(field, filter_.name) else: f = new_class.filter_for_field(field, filter_.name, lookup_expr) f = fix_filter_field(f) # compute filter name filter_name = LOOKUP_SEP.join([name, lookup_expr]) # Don't add "exact" to filter names _exact = LOOKUP_SEP + 'exact' if filter_name.endswith(_exact): filter_name = filter_name[:-len(_exact)] new_class.base_filters[filter_name] = f elif name not in new_class.declared_filters: new_class.base_filters[name] = fix_filter_field(filter_) return new_class
def __init__(self, *args, **kwargs): super(ChainedFilterSet, self).__init__(*args, **kwargs) for name, filter_ in six.iteritems(self.filters): if isinstance(filter_, RelatedFilter): # Populate our FilterSet fields with the fields we've stored # in RelatedFilter. filter_.setup_filterset() populate_from_filterset(filter_.filterset, name, self.filters) elif isinstance(filter_, AllLookupsFilter): # Populate our FilterSet fields with all the possible # filters for the AllLookupsFilter field. model = self._meta.model field = get_model_field(model, filter_.name) for lookup_type in LOOKUP_TYPES: if isinstance(field, RelatedObject): f = self.filter_for_reverse_field(field, filter_.name) else: f = self.filter_for_field(field, filter_.name) f.lookup_type = lookup_type self.filters["%s__%s" % (filter_.name, lookup_type)] = f
def __init__(self, *args, **kwargs): super(ChainedFilterSet, self).__init__(*args, **kwargs) for name, filter_ in six.iteritems(self.filters): if isinstance(filter_, RelatedFilter): # Populate our FilterSet fields with the fields we've stored # in RelatedFilter. filter_.setup_filterset() populate_from_filterset(filter_, name, self.filters) elif isinstance(filter_, AllLookupsFilter): # Populate our FilterSet fields with all the possible # filters for the AllLookupsFilter field. model = self._meta.model field = get_model_field(model, filter_.name) for lookup_type in LOOKUP_TYPES: if isinstance(field, ManyToOneRel): f = self.filter_for_reverse_field(field, filter_.name) else: f = self.filter_for_field(field, filter_.name) f.lookup_type = lookup_type self.filters["%s__%s" % (name, lookup_type)] = f
def test_get_model_field(self): result = get_model_field(User, 'unknown__name') self.assertIsNone(result)
def test_get_model_field(self): result = get_model_field(Business, "hiredworker__worker") self.assertEqual(result, HiredWorker._meta.get_field("worker"))
def test_get_model_field_none(self): result = get_model_field(User, "unknown__name") self.assertIsNone(result)
def test_get_model_field(self): result = get_model_field(Business, 'hiredworker__worker') self.assertEqual(result, HiredWorker._meta.get_field('worker'))
def test_get_model_field_none(self): result = get_model_field(User, 'unknown__name') self.assertIsNone(result)