Merge pull request #43 from rpkilby/filter-exclusion

Add filter exclusion

Author: philipn

README.rst

@@ -164,6 +164,20 @@ then we can filter like so::
 
     /api/page/?author__username__icontains=john
 
+Automatic Filter Negation/Exclusion
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+FilterSets also support automatic exclusion using a simple ``k!=v`` syntax. This syntax
+internally sets the ``exclude`` property on the filter.
+
+    /api/page/?title!=The%20Park
+
+This syntax supports regular filtering combined with exclusion filtering. For example,
+the following would search for all articles containing "Hello" in the title, while
+excluding those containing "World".
+
+    /api/articles/?title__contains=Hello&title__contains!=World
+
 DjangoFilterBackend
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

rest_framework_filters/filterset.py

@@ -2,6 +2,7 @@
 from __future__ import unicode_literals
 
 from collections import OrderedDict
+import copy
 
 from django.db.models.constants import LOOKUP_SEP
 from django.db import models
@@ -82,9 +83,16 @@ def get_filters(self):
 
         # Add plain lookup filters if match. ie, `username__icontains`
         for filter_key, filter_value in six.iteritems(self.filters):
+            exclude_key = '%s!' % filter_key
+
             if filter_key in self.data:
                 requested_filters[filter_key] = filter_value
 
+            if exclude_key in self.data:
+                filter_value = copy.deepcopy(filter_value)
+                filter_value.exclude = not filter_value.exclude
+                requested_filters[exclude_key] = filter_value
+
         # build a map of potential {rel: {filter: value}} data
         related_data = OrderedDict()
         for filter_key, value in six.iteritems(self.data):
@@ -141,11 +149,15 @@ def get_filter_name(cls, param):
         if param in cls.base_filters:
             return param
 
+        # Attempt to match against exclusion filters
+        if param[-1] == '!' and param[:-1] in cls.base_filters:
+            return param[:-1]
+
         # Fallback to matching against relationships. (author__username__endswith)
-        param = param.split(LOOKUP_SEP, 1)[0]
-        f = cls.base_filters.get(param, None)
+        related_param = param.split(LOOKUP_SEP, 1)[0]
+        f = cls.base_filters.get(related_param, None)
         if isinstance(f, filters.RelatedFilter):
-            return param
+            return related_param
 
     def cache_key(self, filterset, filter_names):
         return '%sSubset-%s' % (filterset.__name__, '-'.join(sorted(filter_names)), )

rest_framework_filters/tests.py

@@ -766,3 +766,97 @@ def test_inset_char_filter(self):
         self.assertEqual(len(f), 2)
         self.assertIn(p1, f)
         self.assertIn(p2, f)
+
+
+class FilterSetExclutionTests(TestCase):
+
+    if django.VERSION >= (1, 8):
+        @classmethod
+        def setUpTestData(cls):
+            cls.generateTestData()
+
+    else:
+        def setUp(self):
+            self.generateTestData()
+
+    @classmethod
+    def generateTestData(cls):
+        t1 = Tag.objects.create(name='Tag 1')
+        t2 = Tag.objects.create(name='Tag 2')
+        t3 = Tag.objects.create(name='Something else entirely')
+
+        p1 = BlogPost.objects.create(title='Post 1', content='content 1')
+        p2 = BlogPost.objects.create(title='Post 2', content='content 2')
+
+        p1.tags = [t1, t2]
+        p2.tags = [t3]
+
+    def test_exclude_property(self):
+        """
+        Ensure that the filter is set to exclude
+        """
+        GET = {
+            'name__contains!': 'Tag',
+        }
+
+        filterset = TagFilter(GET, queryset=Tag.objects.all())
+        requested_filters = filterset.get_filters()
+
+        self.assertTrue(requested_filters['name__contains!'].exclude)
+
+    def test_filter_and_exclude(self):
+        """
+        Ensure that both the filter and exclusion filter are available
+        """
+        GET = {
+            'name__contains': 'Tag',
+            'name__contains!': 'Tag',
+        }
+
+        filterset = TagFilter(GET, queryset=Tag.objects.all())
+        requested_filters = filterset.get_filters()
+
+        self.assertFalse(requested_filters['name__contains'].exclude)
+        self.assertTrue(requested_filters['name__contains!'].exclude)
+
+    def test_related_exclude(self):
+        GET = {
+            'tags__name__contains!': 'Tag',
+        }
+
+        filterset = BlogPostFilter(GET, queryset=BlogPost.objects.all())
+        requested_filters = filterset.get_filters()
+
+        self.assertTrue(requested_filters['tags__name__contains!'].exclude)
+
+    def test_exclusion_results(self):
+        GET = {
+            'name__contains!': 'Tag',
+        }
+
+        filterset = TagFilter(GET, queryset=Tag.objects.all())
+        results = [r.name for r in filterset]
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0], 'Something else entirely')
+
+    def test_filter_and_exclusion_results(self):
+        GET = {
+            'name__contains': 'Tag',
+            'name__contains!': '2',
+        }
+
+        filterset = TagFilter(GET, queryset=Tag.objects.all())
+        results = [r.name for r in filterset]
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0], 'Tag 1')
+
+    def test_related_exclusion_results(self):
+        GET = {
+            'tags__name__contains!': 'Tag',
+        }
+
+        filterset = BlogPostFilter(GET, queryset=BlogPost.objects.all())
+        results = [r.title for r in filterset]
+
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0], 'Post 2')