class RegionQueries(graphene.ObjectType):
provinces = BaseDjangoConnectionField(Province, description="List of provinces")
cities = FilterInputConnectionField(
City,
filter=CityFilterInput(description="Filtering options for customers."),
description="List of city.",
)
sub_districts = FilterInputConnectionField(
SubDistrict,
filter=SubDistrictFilterInput(description="Filtering options for customers."),
description="List of districts.",
)
class Group(CountableDjangoObjectType):
users = graphene.List(User, description="List of group users")
permissions = graphene.List(Permission,
description="List of group permissions")
available_staff = FilterInputConnectionField(User, filter=StaffUserInput())
class Meta:
description = "Represents permission group data."
interfaces = [relay.Node]
model = auth_models.Group
only_fields = ["name", "permissions", "id"]
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="user_set")
def resolve_users(root: auth_models.Group, _info):
return root.user_set.all()
@staticmethod
def resolve_permissions(root: auth_models.Group, _info):
permissions = root.permissions.prefetch_related(
"content_type").order_by("codename")
return format_permissions_for_display(permissions)
@staticmethod
def resolve_available_staff(root: auth_models.Group, info, **kwargs):
user = info.context.user
qs = models.User.objects.staff().exclude(id=user.id).exclude(
groups=root)
return qs.distinct()
class DiscountQueries(graphene.ObjectType):
sale = graphene.Field(
Sale,
id=graphene.Argument(graphene.ID,
description="ID of the sale.",
required=True),
description="Look up a sale by ID.",
)
sales = FilterInputConnectionField(
Sale,
filter=SaleFilterInput(description="Filtering options for sales."),
sort_by=SaleSortingInput(description="Sort sales."),
description="List of the shop's sales.",
)
voucher = graphene.Field(
Voucher,
id=graphene.Argument(graphene.ID,
description="ID of the voucher.",
required=True),
description="Look up a voucher by ID.",
)
vouchers = FilterInputConnectionField(
Voucher,
filter=VoucherFilterInput(
description="Filtering options for vouchers."),
sort_by=VoucherSortingInput(description="Sort voucher."),
description="List of the shop's vouchers.",
)
@permission_required(DiscountPermissions.MANAGE_DISCOUNTS)
def resolve_sale(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Sale)
@permission_required(DiscountPermissions.MANAGE_DISCOUNTS)
def resolve_sales(self, info, **kwargs):
return resolve_sales(info, **kwargs)
@permission_required(DiscountPermissions.MANAGE_DISCOUNTS)
def resolve_voucher(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Voucher)
@permission_required(DiscountPermissions.MANAGE_DISCOUNTS)
def resolve_vouchers(self, info, **kwargs):
return resolve_vouchers(info, **kwargs)
class MenuQueries(graphene.ObjectType):
menu = graphene.Field(
Menu,
id=graphene.Argument(graphene.ID,
description="ID of the menu.",
required=True),
description="Look up a navigation menu by ID or name.",
)
menus = FilterInputConnectionField(
Menu,
sort_by=MenuSortingInput(description="Sort menus."),
filter=MenuFilterInput(description="Filtering options for menus."),
description="List of the storefront's menus.",
)
menu_item = graphene.Field(
MenuItem,
id=graphene.Argument(graphene.ID,
description="ID of the menu item.",
required=True),
description="Look up a menu item by ID.",
)
menu_items = FilterInputConnectionField(
MenuItem,
sort_by=MenuItemSortingInput(description="Sort menus items."),
filter=MenuItemFilterInput(
description="Filtering options for menu items."),
description="List of the storefronts's menu items.",
)
def resolve_menu(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Menu)
def resolve_menus(self, info, **kwargs):
return resolve_menus(info, **kwargs)
def resolve_menu_item(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, MenuItem)
def resolve_menu_items(self, info, **kwargs):
return resolve_menu_items(info, **kwargs)
class ProductType(CountableDjangoObjectType):
variant_attributes = graphene.List(
Attribute, description="Variant attributes of that product type.")
product_attributes = graphene.List(
Attribute, description="Product attributes of that product type.")
available_attributes = gql_optimizer.field(
FilterInputConnectionField(Attribute, filter=AttributeFilterInput()))
class Meta:
description = (
"Represents a type of product. It defines what attributes are available to "
"products of this type.")
interfaces = [relay.Node]
model = models.ProductType
only_fields = ["id", "name", "has_variants"]
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related=lambda info: Prefetch(
"product_attributes",
queryset=attributes_models.Attribute.objects.prefetch_related(
"attributeproduct").order_by("attributeproduct__sort_order"),
))
def resolve_product_attributes(root: models.ProductType, info, **_kwargs):
product_type_id = info.variable_values.get(
"id", None) or info.variable_values.get("productTypeId", None)
if product_type_id:
return root.product_attributes.product_attributes_sorted().all()
else:
return root.product_attributes.all()
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related=lambda info: Prefetch(
"variant_attributes",
queryset=attributes_models.Attribute.objects.prefetch_related(
"attributevariant").order_by("attributevariant__sort_order"),
))
def resolve_variant_attributes(root: models.ProductType, info, **_kwargs):
# FIXME: NEED TO RESOLVE BETTER THAN THIS
product_type_id = info.variable_values.get(
"id", None) or info.variable_values.get("productTypeId", None)
if product_type_id:
return root.variant_attributes.variant_attributes_sorted().all()
else:
return root.variant_attributes.all()
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCT_TYPES)
def resolve_available_attributes(root: models.ProductType, _info,
**_kwargs):
return attributes_models.Attribute.objects.get_unassigned_attributes(
root.pk)
class AttributeQueries(graphene.ObjectType):
attribute = graphene.Field(
Attribute,
id=graphene.Argument(graphene.ID, description="ID of the attribute.", required=True),
description="Look up an attribute by ID.",
)
attributes = FilterInputConnectionField(
Attribute,
description="List of the shop's attributes.",
filter=AttributeFilterInput(description="Filtering options for attributes."),
sort_by=AttributeSortingInput(description="Sorting options for attributes."),
)
def resolve_attributes(self, info, **kwargs):
return resolve_attributes(info, **kwargs)
def resolve_attribute(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Attribute)
class PageQueries(graphene.ObjectType):
page = graphene.Field(
Page,
id=graphene.Argument(graphene.ID,
description="ID of the page.",
required=True),
description="Look up a page by ID or slug.",
)
pages = FilterInputConnectionField(
Page,
sort_by=PageSortingInput(description="Sort pages."),
filter=PageFilterInput(description="Filtering options for pages."),
description="List of the shop's pages.",
)
def resolve_page(self, info, id):
return get_node_or_slug(info, id, Page)
def resolve_pages(self, info, **kwargs):
return resolve_pages(info, **kwargs)
class SupplierQueries(graphene.ObjectType):
supplier = graphene.Field(
Supplier,
id=graphene.Argument(graphene.ID,
description="ID of the supplier.",
required=True),
description="Look up a supplier by ID.",
)
suppliers = FilterInputConnectionField(
Supplier,
filter=SupplierFilterInput(
description="Filtering options for suppliers."),
sort_by=SupplierSortingInput(description="Sort product suppliers."),
description="List of the suppliers.",
)
def resolve_supplier(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Supplier)
def resolve_suppliers(self, info, **kwargs):
return resolve_suppliers(info, **kwargs)
class CollectionQueries(graphene.ObjectType):
collection = graphene.Field(
Collection,
id=graphene.Argument(graphene.ID,
description="ID of the collection.",
required=True),
description="Look up a collection by ID.",
)
collections = FilterInputConnectionField(
Collection,
filter=CollectionFilterInput(
description="Filtering options for collections."),
sort_by=CollectionSortingInput(description="Sort collections."),
description="List of the shop's collections.",
)
def resolve_collection(self, info, id):
return get_node_or_slug(info, id, Collection)
def resolve_collections(self, info, **kwargs):
return resolve_collections(info, **kwargs)
class CategoryQueries(graphene.ObjectType):
category = graphene.Field(
Category,
id=graphene.Argument(graphene.ID, description="ID of the category.", required=True),
description="Look up a category by ID or slug.",
)
categories = FilterInputConnectionField(
Category,
filter=CategoryFilterInput(description="Filtering options for categories."),
sort_by=CategorySortingInput(description="Sort categories."),
level=graphene.Argument(
graphene.Int,
description="Filter categories by the nesting level in the category tree.",
),
description="List of the shop's categories.",
)
def resolve_category(self, info, id):
return get_node_or_slug(info, id, Category)
def resolve_categories(self, info, level=None, **kwargs):
return resolve_categories(info, level=level, **kwargs)
class UserQueries(graphene.ObjectType):
address = graphene.Field(
Address,
id=graphene.Argument(graphene.ID, description="ID of an address.", required=True),
description="Look up an address by ID.",
)
customers = FilterInputConnectionField(
User,
filter=CustomerFilterInput(description="Filtering options for customers."),
sort_by=UserSortingInput(description="Sort customers."),
description="List of the shop's customers.",
)
all_permissions = graphene.List(Permission, description="List of store permissions.")
groups = FilterInputConnectionField(
Group,
filter=GroupFilterInput(description="Filtering options for permission groups."),
sort_by=GroupSortingInput(description="Sort permission groups."),
description="List of permission groups.",
)
group = graphene.Field(
Group,
id=graphene.Argument(graphene.ID, description="ID of the group.", required=True),
description="Look up permission group by ID.",
)
me = graphene.Field(User, description="Return the currently authenticated user.")
staff_users = FilterInputConnectionField(
User,
filter=StaffUserInput(description="Filtering options for staff users."),
sort_by=UserSortingInput(description="Sort staff users."),
description="List of the shop's staff users.",
)
user = graphene.Field(
User,
id=graphene.Argument(graphene.ID, description="ID of the user.", required=True),
description="Look up a user by ID.",
)
def resolve_address(self, info, id):
return resolve_address(info, id)
@permission_required(UserPermissions.MANAGE_CUSTOMERS)
def resolve_customers(self, info, **kwargs):
return resolve_customers(info, **kwargs)
@permission_required(GroupPermissions.MANAGE_GROUPS)
def resolve_all_permissions(self, info, **kwargs):
return resolve_all_permissions(info, **kwargs)
@permission_required(GroupPermissions.MANAGE_GROUPS)
def resolve_groups(self, info, **kwargs):
return resolve_groups(info, **kwargs)
@permission_required(GroupPermissions.MANAGE_GROUPS)
def resolve_group(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Group)
def resolve_me(self, info):
user = info.context.user
return user if user.is_authenticated else None
@permission_required(UserPermissions.MANAGE_STAFF)
def resolve_staff_users(self, info, **kwargs):
return resolve_staff_users(info, **kwargs)
@one_of_permissions_required([UserPermissions.MANAGE_STAFF, UserPermissions.MANAGE_CUSTOMERS])
def resolve_user(self, info, id):
return resolve_user(info, id)
class ProductQueries(graphene.ObjectType):
product_type = graphene.Field(
ProductType,
id=graphene.Argument(graphene.ID,
description="ID of the product type.",
required=True),
description="Look up a product type by ID.",
)
product_types = FilterInputConnectionField(
ProductType,
filter=ProductTypeFilterInput(
description="Filtering options for product types."),
sort_by=ProductTypeSortingInput(description="Sort product types."),
description="List of the shop's product types.",
)
product = graphene.Field(
Product,
id=graphene.Argument(graphene.ID,
description="ID of the product.",
required=True),
description="Look up a product by ID.",
)
products = FilterInputConnectionField(
Product,
filter=ProductFilterInput(
description="Filtering options for products."),
sort_by=ProductSortingInput(description="Sort products."),
description="List of the shop's products.",
)
product_variant = graphene.Field(
ProductVariant,
id=graphene.Argument(graphene.ID,
description="ID of the product variant.",
required=True),
description="Look up a product variant by ID.",
)
product_variants = PrefetchingConnectionField(
ProductVariant,
ids=graphene.List(graphene.ID,
description="Filter product variants by given IDs."),
description="List of product variants.",
)
def resolve_product_type(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, ProductType)
def resolve_product_types(self, info, **kwargs):
return resolve_product_types(info, **kwargs)
def resolve_product(self, info, id):
return get_node_or_slug(info, id, Product)
def resolve_products(self, info, **kwargs):
return resolve_products(info, **kwargs)
def resolve_product_variant(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, ProductVariant)
def resolve_product_variants(self, info, ids=None, **_kwargs):
return resolve_product_variants(info, ids)