Esempio n. 1
0
class GiftCardFilter(django_filters.FilterSet):
    tag = django_filters.CharFilter(method=filter_gift_card_tag)
    tags = ListObjectTypeFilter(input_class=graphene.String,
                                method=filter_tags_list)
    products = GlobalIDMultipleChoiceFilter(method=filter_products)
    used_by = GlobalIDMultipleChoiceFilter(method=filter_used_by)
    currency = django_filters.CharFilter(method=filter_currency)
    current_balance = ObjectTypeFilter(input_class=PriceRangeInput,
                                       method="filter_current_balance")
    initial_balance = ObjectTypeFilter(input_class=PriceRangeInput,
                                       method="filter_initial_balance")
    is_active = django_filters.BooleanFilter()
    code = django_filters.CharFilter(method=filter_code)

    class Meta:
        model = models.GiftCard
        fields = ["is_active"]

    def filter_current_balance(self, queryset, name, value):
        check_currency_in_filter_data(self.data)
        return _filter_by_price(queryset, "current_balance", value)

    def filter_initial_balance(self, queryset, name, value):
        check_currency_in_filter_data(self.data)
        return _filter_by_price(queryset, "initial_balance", value)
Esempio n. 2
0
class ProductFilter(MetadataFilterBase):
    is_published = django_filters.BooleanFilter(method="filter_is_published")
    collections = GlobalIDMultipleChoiceFilter(method=filter_collections)
    categories = GlobalIDMultipleChoiceFilter(method=filter_categories)
    has_category = django_filters.BooleanFilter(method=filter_has_category)
    price = ObjectTypeFilter(input_class=PriceRangeInput,
                             method="filter_variant_price")
    minimal_price = ObjectTypeFilter(
        input_class=PriceRangeInput,
        method="filter_minimal_price",
        field_name="minimal_price_amount",
    )
    attributes = ListObjectTypeFilter(
        input_class="saleor.graphql.attribute.types.AttributeInput",
        method="filter_attributes",
    )
    stock_availability = EnumFilter(input_class=StockAvailability,
                                    method="filter_stock_availability")
    product_types = GlobalIDMultipleChoiceFilter(field_name="product_type")
    stocks = ObjectTypeFilter(input_class=ProductStockFilterInput,
                              method=filter_stocks)
    search = django_filters.CharFilter(method=filter_search)
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Product
        fields = [
            "is_published",
            "collections",
            "categories",
            "has_category",
            "attributes",
            "stock_availability",
            "stocks",
            "search",
        ]

    def filter_attributes(self, queryset, name, value):
        return _filter_attributes(queryset, name, value)

    def filter_variant_price(self, queryset, name, value):
        channel_slug = get_channel_slug_from_filter_data(self.data)
        return _filter_variant_price(queryset, name, value, channel_slug)

    def filter_minimal_price(self, queryset, name, value):
        channel_slug = get_channel_slug_from_filter_data(self.data)
        return _filter_minimal_price(queryset, name, value, channel_slug)

    def filter_is_published(self, queryset, name, value):
        channel_slug = get_channel_slug_from_filter_data(self.data)
        return _filter_products_is_published(
            queryset,
            name,
            value,
            channel_slug,
        )

    def filter_stock_availability(self, queryset, name, value):
        channel_slug = get_channel_slug_from_filter_data(self.data)
        return _filter_stock_availability(queryset, name, value, channel_slug)
Esempio n. 3
0
class ProductFilter(django_filters.FilterSet):
    is_published = django_filters.BooleanFilter()
    collections = GlobalIDMultipleChoiceFilter(method=filter_collections)
    categories = GlobalIDMultipleChoiceFilter(method=filter_categories)
    has_category = django_filters.BooleanFilter(method=filter_has_category)
    price = ObjectTypeFilter(
        input_class=PriceRangeInput, method=filter_price, field_name="price_amount"
    )
    minimal_price = ObjectTypeFilter(
        input_class=PriceRangeInput,
        method=filter_minimal_price,
        field_name="minimal_price_amount",
    )
    attributes = ListObjectTypeFilter(
        input_class=AttributeInput, method=filter_attributes
    )
    stock_availability = EnumFilter(
        input_class=StockAvailability, method=filter_stock_availability
    )
    product_type = GlobalIDFilter()
    search = django_filters.CharFilter(method=filter_search)

    class Meta:
        model = Product
        fields = [
            "is_published",
            "collections",
            "categories",
            "has_category",
            "price",
            "attributes",
            "stock_availability",
            "product_type",
            "search",
        ]
Esempio n. 4
0
class PageFilter(MetadataFilterBase):
    search = django_filters.CharFilter(method=filter_page_search)
    page_types = GlobalIDMultipleChoiceFilter(method=filter_page_page_types)
    ids = GlobalIDMultipleChoiceFilter(method=filter_by_id(Page))

    class Meta:
        model = models.Page
        fields = ["search"]
Esempio n. 5
0
class ProductFilter(django_filters.FilterSet):
    is_published = django_filters.BooleanFilter()
    collections = GlobalIDMultipleChoiceFilter(method=filter_collections)
    categories = GlobalIDMultipleChoiceFilter(method=filter_categories)
    has_category = django_filters.BooleanFilter(method=filter_has_category)
    price = ObjectTypeFilter(input_class=PriceRangeInput,
                             method=filter_variant_price)
    minimal_price = ObjectTypeFilter(
        input_class=PriceRangeInput,
        method=filter_minimal_price,
        field_name="minimal_price_amount",
    )
    attributes = ListObjectTypeFilter(
        input_class="saleor.graphql.product.types.attributes.AttributeInput",
        method=filter_attributes,
    )
    stock_availability = EnumFilter(input_class=StockAvailability,
                                    method=filter_stock_availability)
    product_type = GlobalIDFilter()  # Deprecated
    product_types = GlobalIDMultipleChoiceFilter(field_name="product_type")
    stocks = ObjectTypeFilter(input_class=ProductStockFilterInput,
                              method=filter_stocks)
    search = django_filters.CharFilter(method=filter_search)
    ids = GlobalIDMultipleChoiceFilter(field_name="id")
    allegro_status = django_filters.CharFilter(method=filter_allegro_status)
    updated_at = ObjectTypeFilter(input_class=DateRangeInput,
                                  method=filter_updated_at_range)
    created_at = ObjectTypeFilter(input_class=DateRangeInput,
                                  method=filter_created_at_range)
    warehouse_location = ObjectTypeFilter(
        input_class=WarehouseLocationRangeInput,
        method=filter_warehouse_location)

    class Meta:
        model = Product
        fields = [
            "is_published",
            "collections",
            "categories",
            "has_category",
            "attributes",
            "stock_availability",
            "product_type",
            "stocks",
            "search",
            "allegro_status",
            "updated_at",
            "created_at",
            "warehouse_location",
        ]
Esempio n. 6
0
class WarehouseFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(method=filter_search_warehouse)
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Warehouse
        fields = []
class AttributeFilter(django_filters.FilterSet):
    # Search by attribute name and slug
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("slug", "name")
    )
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    in_collection = GlobalIDFilter(method="filter_in_collection")
    in_category = GlobalIDFilter(method="filter_in_category")

    class Meta:
        model = Attribute
        fields = [
            "value_required",
            "is_variant_only",
            "visible_in_storefront",
            "filterable_in_storefront",
            "filterable_in_dashboard",
            "available_in_grid",
        ]

    def filter_in_collection(self, queryset, name, value):
        requestor = get_user_or_app_from_context(self.request)
        return filter_attributes_by_product_types(queryset, name, value, requestor)

    def filter_in_category(self, queryset, name, value):
        requestor = get_user_or_app_from_context(self.request)
        return filter_attributes_by_product_types(queryset, name, value, requestor)
Esempio n. 8
0
class PageFilter(MetadataFilterBase):
    search = django_filters.CharFilter(method=filter_page_search)
    page_types = GlobalIDMultipleChoiceFilter(field_name="page_type")

    class Meta:
        model = Page
        fields = ["search"]
Esempio n. 9
0
class CollectionFilter(MetadataFilterBase):
    published = EnumFilter(input_class=CollectionPublished,
                           method="filter_is_published")
    search = django_filters.CharFilter(method="collection_filter_search")
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Collection
        fields = ["published", "search"]

    def collection_filter_search(self, queryset, _name, value):
        if not value:
            return queryset
        name_slug_qs = Q(name__ilike=value) | Q(slug__ilike=value)
        return queryset.filter(name_slug_qs)

    def filter_is_published(self, queryset, name, value):
        channel_slug = get_channel_slug_from_filter_data(self.data)
        if value == CollectionPublished.PUBLISHED:
            return _filter_collections_is_published(queryset, name, True,
                                                    channel_slug)
        elif value == CollectionPublished.HIDDEN:
            return _filter_collections_is_published(queryset, name, False,
                                                    channel_slug)
        return queryset
Esempio n. 10
0
class ShippingZoneFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(method=filter_fields_containing_value("name"))
    channels = GlobalIDMultipleChoiceFilter(method=filter_channels)

    class Meta:
        model = ShippingZone
        fields = ["search"]
Esempio n. 11
0
class SupplierFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("name", "email", "phone"))
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Supplier
        fields = ["search"]
Esempio n. 12
0
class CategoryFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("slug", "name", "description"))
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Category
        fields = ["search"]
Esempio n. 13
0
class PackageLineFilter(django_filters.FilterSet):
    # search = django_filters.CharFilter(method=filter_packageLine_search)
    fulfillmentline = GlobalIDMultipleChoiceFilter(field_name="fulfillmentline_id")
    # is_active = django_filters.BooleanFilter()

    class Meta:
        model = models.PackageLine
        # fields = ["search", "is_active"]
        fields = ["fulfillmentline"]
Esempio n. 14
0
class CategoryFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("slug", "name"))
    ids = GlobalIDMultipleChoiceFilter(field_name="id")
    parent = GlobalIDFilter()

    # used in sales
    sales = GlobalIDMultipleChoiceFilter(method=filter_sales)
    not_in_sales = GlobalIDMultipleChoiceFilter(method=filter_not_in_sales)

    # used in vouchers
    vouchers = GlobalIDMultipleChoiceFilter(method=filter_vouchers)
    not_in_vouchers = GlobalIDMultipleChoiceFilter(
        method=filter_not_in_vouchers)

    class Meta:
        model = Category
        fields = ["search", "parent"]
Esempio n. 15
0
class ProductFilter(django_filters.FilterSet):
    is_published = django_filters.BooleanFilter()
    collections = GlobalIDMultipleChoiceFilter(method=filter_collections)
    categories = GlobalIDMultipleChoiceFilter(method=filter_categories)
    price = ObjectTypeFilter(input_class=PriceRangeInput, method=filter_price)
    attributes = ListObjectTypeFilter(input_class=AttributeInput,
                                      method=filter_attributes)
    stock_availability = EnumFilter(input_class=StockAvailability,
                                    method=filter_stock_availability)
    product_type = GlobalIDFilter()
    search = django_filters.CharFilter(method=filter_search)

    class Meta:
        model = Product
        fields = [
            'is_published', 'collections', 'categories', 'price', 'attributes',
            'stock_availability', 'product_type', 'search'
        ]
Esempio n. 16
0
class DraftOrderFilter(MetadataFilterBase):
    customer = django_filters.CharFilter(method=filter_customer)
    created = ObjectTypeFilter(input_class=DateRangeInput, method=filter_created_range)
    search = django_filters.CharFilter(method=filter_order_search)
    channels = GlobalIDMultipleChoiceFilter(method=filter_channels)

    class Meta:
        model = Order
        fields = ["customer", "created", "search"]
Esempio n. 17
0
class OrderFilter(DraftOrderFilter):
    payment_status = ListObjectTypeFilter(
        input_class=PaymentChargeStatusEnum, method=filter_payment_status
    )
    status = ListObjectTypeFilter(input_class=OrderStatusFilter, method=filter_status)
    customer = django_filters.CharFilter(method=filter_customer)
    created = ObjectTypeFilter(input_class=DateRangeInput, method=filter_created_range)
    search = django_filters.CharFilter(method=filter_order_search)
    channels = GlobalIDMultipleChoiceFilter(method=filter_channels)
    is_click_and_collect = django_filters.BooleanFilter(
        method=filter_is_click_and_collect
    )
    is_preorder = django_filters.BooleanFilter(method=filter_is_preorder)
    ids = GlobalIDMultipleChoiceFilter(method=filter_order_ids)

    class Meta:
        model = Order
        fields = ["payment_status", "status", "customer", "created", "search"]
Esempio n. 18
0
class CollectionFilter(django_filters.FilterSet):
    published = EnumFilter(input_class=CollectionPublished,
                           method=filter_collection_publish)
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("slug", "name"))
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Collection
        fields = ["published", "search"]
Esempio n. 19
0
class WarehouseFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(method=filter_search_warehouse)
    ids = GlobalIDMultipleChoiceFilter(field_name="id")
    is_private = django_filters.BooleanFilter(field_name="is_private")
    click_and_collect_option = EnumFilter(
        input_class=WarehouseClickAndCollectOptionEnum,
        method=filter_click_and_collect_option,
    )

    class Meta:
        model = Warehouse
        fields = ["click_and_collect_option"]
Esempio n. 20
0
class ProductTypeFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("name", "slug"))

    configurable = EnumFilter(input_class=ProductTypeConfigurable,
                              method=filter_product_type_configurable)

    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = ProductType
        fields = ["search", "configurable"]
Esempio n. 21
0
class WmsDocumentFilter(django_filters.FilterSet):
    document_type = ListObjectTypeFilter(input_class=WmsDocumentTypeFilter,
                                         method=filter_document_type)
    created_by = GlobalIDMultipleChoiceFilter(method=filter_created_by)
    recipients = GlobalIDMultipleChoiceFilter(method=filter_recipients)
    deliverers = GlobalIDMultipleChoiceFilter(method=filter_deliverers)
    status = ListObjectTypeFilter(input_class=WmsDocumentStatusFilter,
                                  method=filter_status)
    location = django_filters.CharFilter(method=filter_location)
    created_at = ObjectTypeFilter(input_class=DateRangeInput,
                                  method=filter_created_at_range)
    updated_at = ObjectTypeFilter(input_class=DateRangeInput,
                                  method=filter_updated_at_range)
    warehouses = GlobalIDMultipleChoiceFilter(method=filter_warehouses)
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("number"))

    class Meta:
        model = models.WmsDocument
        fields = [
            "document_type", "created_by", "recipients", "deliverers",
            "status", "location", "created_at", "updated_at", "warehouses"
        ]
Esempio n. 22
0
class StaffUserFilter(django_filters.FilterSet):
    status = EnumFilter(input_class=StaffMemberStatus, method=filter_staff_status)
    search = django_filters.CharFilter(method=filter_user_search)
    ids = GlobalIDMultipleChoiceFilter(
        method=filter_by_id(
            account_types.User,
        )
    )
    # TODO - Figure out after permission types
    # department = ObjectTypeFilter

    class Meta:
        model = User
        fields = ["status", "search"]
Esempio n. 23
0
class AttributeFilter(django_filters.FilterSet):
    # Search by attribute name and slug
    search = django_filters.CharFilter(method=filter_attributes_search)
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Attribute
        fields = [
            "value_required",
            "is_variant_only",
            "visible_in_storefront",
            "filterable_in_storefront",
            "filterable_in_dashboard",
            "available_in_grid",
        ]
Esempio n. 24
0
class CategoryFilter(MetadataFilterBase):
    search = django_filters.CharFilter(method="category_filter_search")
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Category
        fields = ["search"]

    @classmethod
    def category_filter_search(cls, queryset, _name, value):
        if not value:
            return queryset
        name_slug_desc_qs = (Q(name__ilike=value)
                             | Q(slug__ilike=value)
                             | Q(description_plaintext__ilike=value))

        return queryset.filter(name_slug_desc_qs)
Esempio n. 25
0
class CollectionFilter(MetadataFilterBase):
    published = EnumFilter(input_class=CollectionPublished,
                           method="filter_is_published")
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("slug", "name"))
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = Collection
        fields = ["published", "search"]

    def filter_is_published(self, queryset, name, value):
        channel_slug = get_channel_slug_from_filter_data(self.data)
        if value == CollectionPublished.PUBLISHED:
            return _filter_is_published(queryset, name, True, channel_slug)
        elif value == CollectionPublished.HIDDEN:
            return _filter_is_published(queryset, name, False, channel_slug)
        return queryset
Esempio n. 26
0
class ProductFilter(django_filters.FilterSet):
    is_published = django_filters.BooleanFilter()
    has_category = django_filters.BooleanFilter(method=filter_has_category)
    price = ObjectTypeFilter(input_class=PriceRangeInput, method=filter_price)
    attributes = ListObjectTypeFilter(input_class=AttributeInput,
                                      method=filter_attributes)
    stock_availability = EnumFilter(input_class=StockAvailability,
                                    method=filter_stock_availability)
    product_types = GlobalIDMultipleChoiceFilter(field_name="product_type")

    search = django_filters.CharFilter(method=filter_search)

    # used in categories
    categories = GlobalIDMultipleChoiceFilter(method=filter_categories)

    # used in collections
    collections = GlobalIDMultipleChoiceFilter(method=filter_collections)
    not_in_collections = GlobalIDMultipleChoiceFilter(
        method=filter_not_in_collections)

    # used in sales
    sales = GlobalIDMultipleChoiceFilter(method=filter_sales)
    not_in_sales = GlobalIDMultipleChoiceFilter(method=filter_not_in_sales)

    # used in vouchers
    vouchers = GlobalIDMultipleChoiceFilter(method=filter_vouchers)
    not_in_vouchers = GlobalIDMultipleChoiceFilter(
        method=filter_not_in_vouchers)

    class Meta:
        model = Product
        fields = [
            "is_published",
            "collections",
            "categories",
            "has_category",
            "price",
            "attributes",
            "stock_availability",
            "product_type",
            "search",
        ]
Esempio n. 27
0
class AttributeFilter(django_filters.FilterSet):
    # Search by attribute name and slug
    search = django_filters.CharFilter(
        method=filter_fields_containing_value("slug", "name"))
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    in_collection = GlobalIDFilter(method=filter_attributes_by_product_types)
    in_category = GlobalIDFilter(method=filter_attributes_by_product_types)

    class Meta:
        model = Attribute
        fields = [
            "value_required",
            "is_variant_only",
            "visible_in_storefront",
            "filterable_in_storefront",
            "filterable_in_dashboard",
            "available_in_grid",
        ]
Esempio n. 28
0
class ProductTypeFilter(MetadataFilterBase):
    search = django_filters.CharFilter(method="filter_product_type_searchable")

    configurable = EnumFilter(input_class=ProductTypeConfigurable,
                              method=filter_product_type_configurable)

    product_type = EnumFilter(input_class=ProductTypeEnum,
                              method=filter_product_type)
    kind = EnumFilter(input_class=ProductTypeKindEnum,
                      method=filter_product_type_kind)
    ids = GlobalIDMultipleChoiceFilter(field_name="id")

    class Meta:
        model = ProductType
        fields = ["search", "configurable", "product_type"]

    @classmethod
    def filter_product_type_searchable(cls, queryset, _name, value):
        if not value:
            return queryset
        name_slug_qs = Q(name__ilike=value) | Q(slug__ilike=value)
        return queryset.filter(name_slug_qs)
Esempio n. 29
0
class ProductCategoryNodeFilter(django_filters.FilterSet):
    id = GlobalIDMultipleChoiceFilter()  #filter by List not actually working
    level = django_filters.CharFilter()
    parent = django_filters.CharFilter()
Esempio n. 30
0
class PermissionGroupFilter(django_filters.FilterSet):
    search = django_filters.CharFilter(method=filter_search)
    ids = GlobalIDMultipleChoiceFilter(method=filter_by_id(account_types.Group))