__in filter works with strings.

Author: karmux

rest_framework_filters/fields.py

@@ -15,3 +15,14 @@ def clean(self, value):
         for val in value.split(','):
             out.append(super(ArrayDecimalField, self).clean(val))
         return out
+
+
+class ArrayCharField(forms.CharField):
+    def clean(self, value):
+        if value is None:
+            return None
+
+        out = []
+        for val in value.split(','):
+            out.append(super(ArrayCharField, self).clean(val))
+        return out

rest_framework_filters/filters.py

@@ -39,9 +39,7 @@ class TimeFilter(TimeFilter):
         field_class = fields.Django14TimeField
 
 
-class InSetNumberFilter(NumberFilter):
-    field_class = fields.ArrayDecimalField
-
+class InSetFilterBase(object):
     def filter(self, qs, value):
         if value in ([], (), {}, None, ''):
             return qs
@@ -50,3 +48,11 @@ def filter(self, qs, value):
         if self.distinct:
             qs = qs.distinct()
         return qs
+
+
+class InSetNumberFilter(InSetFilterBase, NumberFilter):
+    field_class = fields.ArrayDecimalField
+
+
+class InSetCharFilter(InSetFilterBase, NumberFilter):
+    field_class = fields.ArrayCharField

rest_framework_filters/filterset.py

@@ -74,8 +74,10 @@ def fix_filter_field(self, f):
         lookup_type = f.lookup_type
         if lookup_type == 'isnull':
             return filters.BooleanFilter(name=("%s%sisnull" % (f.name, LOOKUP_SEP)))
-        if lookup_type == 'in' and type(f) in [filters.NumberFilter]:
+        if lookup_type == 'in' and type(f) == filters.NumberFilter:
             return filters.InSetNumberFilter(name=("%s%sin" % (f.name, LOOKUP_SEP)))
+        if lookup_type == 'in' and type(f) == filters.CharFilter:
+            return filters.InSetCharFilter(name=("%s%sin" % (f.name, LOOKUP_SEP)))
         return f
 
     def populate_from_filterset(self, filterset, filter_, name):

rest_framework_filters/tests.py

@@ -238,12 +238,21 @@ class ExplicitLookupsPersonDateFilter(FilterSet):
     class Meta:
         model = Person
 
-class InSetLookupPersonFilter(FilterSet):
+
+class InSetLookupPersonIDFilter(FilterSet):
     pk = AllLookupsFilter('id')
 
     class Meta:
         model = Person
 
+
+class InSetLookupPersonNameFilter(FilterSet):
+    name = AllLookupsFilter('name')
+
+    class Meta:
+        model = Person
+
+
 class TestFilterSets(TestCase):
 
     if django.VERSION >= (1, 8):
@@ -679,14 +688,14 @@ class Meta:
         p = list(f)[0]
         self.assertEqual(p.name, "John")
 
-    def test_inset_filter(self):
+    def test_inset_number_filter(self):
         p1 = Person.objects.get(name="John").pk
         p2 = Person.objects.get(name="Mark").pk
 
         ALL_GET = {
             'pk__in': '{:d},{:d}'.format(p1, p2),
         }
-        f = InSetLookupPersonFilter(ALL_GET, queryset=Person.objects.all())
+        f = InSetLookupPersonIDFilter(ALL_GET, queryset=Person.objects.all())
         f = [x.pk for x in f]
         self.assertEqual(len(f), 2)
         self.assertIn(p1, f)
@@ -696,13 +705,13 @@ def test_inset_filter(self):
         INVALID_GET = {
             'pk__in': '{:d},c{:d}'.format(p1, p2)
         }
-        f = InSetLookupPersonFilter(INVALID_GET, queryset=Person.objects.all())
+        f = InSetLookupPersonIDFilter(INVALID_GET, queryset=Person.objects.all())
         self.assertEqual(len(list(f)), 0)
 
         EXTRA_GET = {
             'pk__in': '{:d},{:d},{:d}'.format(p1, p2, p1*p2)
         }
-        f = InSetLookupPersonFilter(EXTRA_GET, queryset=Person.objects.all())
+        f = InSetLookupPersonIDFilter(EXTRA_GET, queryset=Person.objects.all())
         f = [x.pk for x in f]
         self.assertEqual(len(f), 2)
         self.assertIn(p1, f)
@@ -711,8 +720,45 @@ def test_inset_filter(self):
         DISORDERED_GET = {
             'pk__in': '{:d},{:d},{:d}'.format(p2, p2*p1, p1)
         }
-        f = InSetLookupPersonFilter(DISORDERED_GET, queryset=Person.objects.all())
+        f = InSetLookupPersonIDFilter(DISORDERED_GET, queryset=Person.objects.all())
         f = [x.pk for x in f]
         self.assertEqual(len(f), 2)
         self.assertIn(p1, f)
         self.assertIn(p2, f)
+
+    def test_inset_char_filter(self):
+        p1 = Person.objects.get(name="John").name
+        p2 = Person.objects.get(name="Mark").name
+
+        ALL_GET = {
+            'name__in': '{},{}'.format(p1, p2),
+        }
+        f = InSetLookupPersonNameFilter(ALL_GET, queryset=Person.objects.all())
+        f = [x.name for x in f]
+        self.assertEqual(len(f), 2)
+        self.assertIn(p1, f)
+        self.assertIn(p2, f)
+
+        NONEXISTENT_GET = {
+            'name__in': '{},Foo{}'.format(p1, p2)
+        }
+        f = InSetLookupPersonNameFilter(NONEXISTENT_GET, queryset=Person.objects.all())
+        self.assertEqual(len(list(f)), 1)
+
+        EXTRA_GET = {
+            'name__in': '{},{},{}'.format(p1, p2, p1+p2)
+        }
+        f = InSetLookupPersonNameFilter(EXTRA_GET, queryset=Person.objects.all())
+        f = [x.name for x in f]
+        self.assertEqual(len(f), 2)
+        self.assertIn(p1, f)
+        self.assertIn(p2, f)
+
+        DISORDERED_GET = {
+            'name__in': '{},{},{}'.format(p2, p2+p1, p1)
+        }
+        f = InSetLookupPersonNameFilter(DISORDERED_GET, queryset=Person.objects.all())
+        f = [x.name for x in f]
+        self.assertEqual(len(f), 2)
+        self.assertIn(p1, f)
+        self.assertIn(p2, f)