class PostFilter(FilterSet):
    # Used for Related filter and Filter.method regression tests
    title = filters.AutoFilter(field_name='title', lookups='__all__')

    publish_date = filters.AutoFilter(lookups='__all__')
    is_published = filters.BooleanFilter(method='filter_is_published')

    author = RelatedFilter(UserFilter,
                           field_name='author',
                           queryset=User.objects.all())
    note = RelatedFilter(NoteFilter,
                         field_name='note',
                         queryset=Note.objects.all())
    tags = RelatedFilter(TagFilter,
                         field_name='tags',
                         queryset=Tag.objects.all())

    class Meta:
        model = Post
        fields = []

    def filter_is_published(self, queryset, field_name, value):
        """
        `is_published` is based on the actual `publish_date`. If the
        publish date is null, then the post is not published.

        This filter method is used to demonstrate annotations.
        """
        # Note: don't modify this without updating test_filtering.AnnotationTests
        return queryset.annotate_is_published() \
                       .filter(**{field_name: value})
Exemple #2
0
        class F(FilterSet):
            author = filters.AutoFilter(field_name='author__last_name',
                                        lookups='__all__')

            class Meta:
                model = Note
                fields = []
Exemple #3
0
        class F(FilterSet):
            id = filters.AutoFilter(lookups='__all__')
            id__in = f

            class Meta:
                model = Note
                fields = []
Exemple #4
0
class NoteFilterWithRelatedAll(DRFFilterSet):
    title = filters.AutoFilter(lookups='__all__')
    author = filters.RelatedFilter(UserFilterWithAll, queryset=User.objects.all())

    class Meta:
        model = Note
        fields = []
        class F(FilterSet):
            pk = filters.AutoFilter(field_name='id', lookups=['exact'])
            individual = filters.CharFilter()

            class Meta:
                model = Note
                fields = []
    def test_autofilter_not_declared(self):
        # AutoFilter is not an actual Filter subclass
        f = filters.AutoFilter(lookups=['exact'])

        class F(FilterSet):
            id = f

        self.assertEqual(F.auto_filters, {'id': f})
        self.assertEqual(F.declared_filters, {})
        class F(FilterSet):
            id = filters.AutoFilter(lookups='__all__',
                                    method='filterset_method')
            title = filters.AutoFilter(lookups=['exact'],
                                       method=external_method)
            author = filters.AutoFilter(field_name='author__last_name',
                                        lookups='__all__',
                                        method='related_method')

            class Meta:
                model = Note
                fields = []

            def filterset_method(self, qs, field, value):
                pass

            def related_method(self, qs, field, value):
                pass
 class Mixin(FilterSet):
     title = filters.AutoFilter(lookups='__all__')
Exemple #9
0
class UserFilterWithAll(DRFFilterSet):
    username = filters.AutoFilter(lookups='__all__')

    class Meta:
        model = User
        fields = []
        class F(FilterSet):
            id = filters.AutoFilter(lookups=[])

            class Meta:
                model = Note
                fields = []
 class Mixin(FilterSet):
     title = filters.AutoFilter(lookups=['exact'])
Exemple #12
0
            class F(FilterSet):
                pk = filters.AutoFilter(field_name='xyz', lookups=['exact'])

                class Meta:
                    model = Note
                    fields = []