Filtering interface implementation

saleor/graphql/core/fields.py

@@ -1,3 +1,5 @@
+from functools import partial
+
 import graphene
 from django.db.models.query import QuerySet
 from django_measurement.models import MeasurementField
@@ -66,3 +68,46 @@ def resolve_connection(cls, connection, default_manager, args, iterable):
         connection.iterable = iterable
         connection.length = _len
         return connection
+
+
+class FilterInputConnectionField(DjangoConnectionField):
+    def __init__(self, type, *args, **kwargs):
+        self.filters_obj = kwargs.get('filters')
+        self.filterset_class = None
+        if self.filters_obj:
+            self.filterset_class = self.filters_obj.filterset_class
+        super().__init__(type, *args, **kwargs)
+
+    @classmethod
+    def connection_resolver(
+            cls, resolver, connection, default_manager, max_limit,
+            enforce_first_or_last, filterset_class, root, info, **args):
+        filters_input = args.get('filters')
+        qs = default_manager
+        if filters_input and filterset_class:
+            qs = filterset_class(
+                data=dict(filters_input),
+                queryset=default_manager.get_queryset(),
+                request=info.context).qs
+
+        return super().connection_resolver(
+            resolver,
+            connection,
+            qs,
+            max_limit,
+            enforce_first_or_last,
+            root,
+            info,
+            **args
+        )
+
+    def get_resolver(self, parent_resolver):
+        return partial(
+            self.connection_resolver,
+            parent_resolver,
+            self.type,
+            self.get_manager(),
+            self.max_limit,
+            self.enforce_first_or_last,
+            self.filterset_class
+        )

saleor/graphql/core/filters.py

@@ -0,0 +1,12 @@
+import django_filters
+
+
+class EnumFilter(django_filters.CharFilter):
+    """
+    Filter for GraphQL's enum objects. enum_class stores graphQL enum
+    needed to generated schema. method needs to be always pass explicitly"""
+    def __init__(self, enum_class, *args, **kwargs):
+        assert kwargs.get('method'), ("Providing exact filter method is "
+                                      "required for EnumFilter")
+        self.enum_class = enum_class
+        super().__init__(*args, **kwargs)

saleor/graphql/core/types/__init__.py

@@ -1,6 +1,7 @@
 from .common import (
-    CountryDisplay, Error, Image, LanguageDisplay, PermissionDisplay,
-    SeoInput, Weight)
+    CountryDisplay, Error, Image, LanguageDisplay, PermissionDisplay, SeoInput,
+    Weight)
+from .filter_input import FilterInputObjectType
 from .money import (
     VAT, Money, MoneyRange, ReducedRate, TaxedMoney, TaxedMoneyRange)
 from .upload import Upload

saleor/graphql/core/types/filter_input.py

@@ -0,0 +1,62 @@
+import six
+from graphene import InputField, InputObjectType
+from graphene.types.inputobjecttype import InputObjectTypeOptions
+from graphene.types.utils import yank_fields_from_attrs
+from graphene_django.filter.utils import get_filterset_class
+from graphene_django.forms.converter import convert_form_field
+
+from saleor.graphql.core.filters import EnumFilter
+
+
+class FilterInputObjectType(InputObjectType):
+    @classmethod
+    def __init_subclass_with_meta__(
+            cls, container=None, _meta=None, model=None, filterset_class=None,
+            fields=None,  **options):
+        cls.custom_filterset_class = filterset_class
+        cls.filterset_class = None
+        cls.fields = fields
+        cls.model = model
+
+        if not _meta:
+            _meta = InputObjectTypeOptions(cls)
+
+        fields = cls.get_filtering_args_from_filterset()
+        fields = yank_fields_from_attrs(fields, _as=InputField)
+        if _meta.fields:
+            _meta.fields.update(fields)
+        else:
+            _meta.fields = fields
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    def get_filtering_args_from_filterset(cls):
+        """ Inspect a FilterSet and produce the arguments to pass to
+            a Graphene Field. These arguments will be available to
+            filter against in the GraphQL
+        """
+        if not cls.custom_filterset_class:
+            assert cls.model and cls.fields, (
+                "Provide filterset class or model and fields requested to "
+                "create default filterset")
+
+        meta = dict(model=cls.model, fields=cls.fields)
+        cls.filterset_class = get_filterset_class(
+            cls.custom_filterset_class, **meta
+        )
+
+        args = {}
+        for name, filter_field in six.iteritems(
+                cls.filterset_class.base_filters):
+            enum_type = isinstance(filter_field, EnumFilter)
+            if enum_type:
+                field_type = filter_field.enum_class()
+            else:
+                field_type = convert_form_field(filter_field.field)
+                field_type.description = filter_field.label
+            kwargs = getattr(field_type, 'kwargs', {})
+            kwargs['name'] = name
+            field_type.kwargs = kwargs
+            args[name] = field_type
+        return args

saleor/graphql/product/filters.py

@@ -2,9 +2,10 @@
 import operator
 from collections import defaultdict
 
+import django_filters
 from django.db.models import Q
 
-from ...product.models import Attribute
+from ...product.models import Attribute, Product
 
 
 def filter_products_by_attributes(qs, filter_value):
@@ -59,3 +60,16 @@ def sort_qs(qs, sort_by_product_order):
         qs = qs.order_by(sort_by_product_order['direction']
                          + sort_by_product_order['field'])
     return qs
+
+
+class ProductFilter(django_filters.FilterSet):
+    is_published = django_filters.BooleanFilter()
+
+    class Meta:
+        model = Product
+        fields = {
+            'name': ['exact', 'icontains'],
+            'category': ['exact'],
+            'product_type__id': ['exact'],
+            'price': ['exact', 'lt', 'gt'],
+        }

saleor/graphql/product/schema.py

@@ -1,10 +1,12 @@
 from textwrap import dedent
 
 import graphene
+from graphene_django.filter import DjangoFilterConnectionField
 from graphql_jwt.decorators import permission_required
 
 from ..core.enums import ReportingPeriod
-from ..core.fields import PrefetchingConnectionField
+from ..core.fields import (
+    FilterInputConnectionField, PrefetchingConnectionField)
 from ..descriptions import DESCRIPTIONS
 from ..translations.mutations import (
     AttributeTranslate, AttributeValueTranslate, CategoryTranslate,
@@ -35,8 +37,8 @@
     resolve_products, resolve_report_product_sales)
 from .scalars import AttributeScalar
 from .types import (
-    Attribute, Category, Collection, DigitalContent, Product, ProductOrder,
-    ProductType, ProductVariant)
+    Attribute, Category, Collection, DigitalContent, Product,
+    ProductFilterInput, ProductOrder, ProductType, ProductVariant)
 
 
 class ProductQueries(graphene.ObjectType):
@@ -76,8 +78,9 @@ class ProductQueries(graphene.ObjectType):
     product = graphene.Field(
         Product, id=graphene.Argument(graphene.ID, required=True),
         description='Lookup a product by ID.')
-    products = PrefetchingConnectionField(
+    products = FilterInputConnectionField(
         Product,
+        filters=ProductFilterInput(),
         attributes=graphene.List(
             AttributeScalar, description='Filter products by attributes.'),
         categories=graphene.List(

saleor/graphql/product/types.py

@@ -18,7 +18,9 @@
 from ..core.connection import CountableDjangoObjectType
 from ..core.enums import ReportingPeriod, TaxRateType
 from ..core.fields import PrefetchingConnectionField
-from ..core.types import Image, Money, MoneyRange, TaxedMoney, TaxedMoneyRange
+from ..core.types import (
+    FilterInputObjectType, Image, Money, MoneyRange, TaxedMoney,
+    TaxedMoneyRange)
 from ..translations.enums import LanguageCodeEnum
 from ..translations.resolvers import resolve_translation
 from ..translations.types import (
@@ -27,6 +29,7 @@
 from ..utils import get_database_id, reporting_period_to_date
 from .descriptions import AttributeDescriptions, AttributeValueDescriptions
 from .enums import AttributeValueType, OrderDirection, ProductOrderField
+from .filters import ProductFilter
 
 COLOR_PATTERN = r'^(#[0-9a-fA-F]{3}|#(?:[0-9a-fA-F]{2}){2,4}|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))$'  # noqa
 color_pattern = re.compile(COLOR_PATTERN)
@@ -301,6 +304,11 @@ class Meta:
         description = 'Represents availability of a product in the storefront.'
 
 
+class ProductFilterInput(FilterInputObjectType):
+    class Meta:
+        filterset_class = ProductFilter
+
+
 class Product(CountableDjangoObjectType):
     url = graphene.String(
         description='The storefront URL for the product.', required=True)

saleor/graphql/schema.graphql

@@ -1720,6 +1720,17 @@ type ProductDelete {
   product: Product
 }
 
+input ProductFilterInput {
+  name: String
+  name__icontains: String
+  category: ID
+  product_type__id: ID
+  price: Float
+  price__lt: Float
+  price__gt: Float
+  is_published: Boolean
+}
+
 type ProductImage implements Node {
   sortOrder: Int!
   id: ID!
@@ -1969,7 +1980,7 @@ type Query {
   collection(id: ID!): Collection
   collections(query: String, before: String, after: String, first: Int, last: Int): CollectionCountableConnection
   product(id: ID!): Product
-  products(attributes: [AttributeScalar], categories: [ID], collections: [ID], priceLte: Float, priceGte: Float, sortBy: ProductOrder, stockAvailability: StockAvailability, query: String, before: String, after: String, first: Int, last: Int): ProductCountableConnection
+  products(filters: ProductFilterInput, attributes: [AttributeScalar], categories: [ID], collections: [ID], priceLte: Float, priceGte: Float, sortBy: ProductOrder, stockAvailability: StockAvailability, query: String, before: String, after: String, first: Int, last: Int): ProductCountableConnection
   productType(id: ID!): ProductType
   productTypes(before: String, after: String, first: Int, last: Int): ProductTypeCountableConnection
   productVariant(id: ID!): ProductVariant