class Arguments:
title = graphene.String()
body = graphene.String()
publish_date = graphene.types.datetime.Date()
public = graphene.Boolean()
slug = graphene.String()
class ProductVariant(CountableDjangoObjectType):
quantity = graphene.Int(
required=True,
description="Quantity of a product available for sale.",
deprecation_reason=
("Use the stock field instead. This field will be removed after 2020-07-31."
),
)
quantity_allocated = graphene.Int(
required=False,
description="Quantity allocated for orders.",
deprecation_reason=
("Use the stock field instead. This field will be removed after 2020-07-31."
),
)
stock_quantity = graphene.Int(
required=True,
description="Quantity of a product available for sale.",
deprecation_reason=("Use the quantityAvailable field instead. "
"This field will be removed after 2020-07-31."),
)
price_override = graphene.Field(
Money,
description=
("Override the base price of a product if necessary. A value of `null` "
"indicates that the default product price is used."),
)
pricing = graphene.Field(
VariantPricingInfo,
description=
("Lists the storefront variant's pricing, the current price and discounts, "
"only meant for displaying."),
)
is_available = graphene.Boolean(
description="Whether the variant is in stock and visible or not.",
deprecation_reason=
("Use the stock field instead. This field will be removed after 2020-07-31."
),
)
attributes = graphene.List(
graphene.NonNull(SelectedAttribute),
required=True,
description="List of attributes assigned to this variant.",
)
cost_price = graphene.Field(Money,
description="Cost price of the variant.")
margin = graphene.Int(description="Gross margin percentage value.")
quantity_ordered = graphene.Int(description="Total quantity ordered.")
revenue = graphene.Field(
TaxedMoney,
period=graphene.Argument(ReportingPeriod),
description=
("Total revenue generated by a variant in given period of time. Note: this "
"field should be queried using `reportProductSales` query as it uses "
"optimizations suitable for such calculations."),
)
images = graphene.List(
lambda: ProductImage,
description="List of images for the product variant.")
translation = TranslationField(ProductVariantTranslation,
type_name="product variant")
digital_content = graphene.Field(
DigitalContent, description="Digital content for the product variant.")
stocks = graphene.Field(
graphene.List(Stock),
description="Stocks for the product variant.",
country_code=graphene.Argument(
CountryCodeEnum,
description="Two-letter ISO 3166-1 country code.",
required=False,
),
)
quantity_available = graphene.Int(
required=True,
description="Quantity of a product available for sale in one checkout.",
country_code=graphene.Argument(
CountryCodeEnum,
description=
("Two-letter ISO 3166-1 country code. When provided, the exact quantity "
"from a warehouse operating in shipping zones that contain this "
"country will be returned. Otherwise, it will return the maximum "
"quantity from all shipping zones."),
),
)
class Meta:
description = (
"Represents a version of a product such as different size or color."
)
only_fields = [
"id", "name", "product", "sku", "track_inventory", "weight"
]
interfaces = [relay.Node, ObjectWithMetadata]
model = models.ProductVariant
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_stocks(root: models.ProductVariant, info, country_code=None):
if not country_code:
return root.stocks.annotate_available_quantity()
return root.stocks.for_country(
country_code).annotate_available_quantity()
@staticmethod
def resolve_quantity_available(root: models.ProductVariant,
info,
country_code=None):
if not root.track_inventory:
return settings.MAX_CHECKOUT_LINE_QUANTITY
return AvailableQuantityByProductVariantIdAndCountryCodeLoader(
info.context).load((root.id, country_code))
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_digital_content(root: models.ProductVariant, *_args):
return getattr(root, "digital_content", None)
@staticmethod
def resolve_stock_quantity(root: models.ProductVariant, info):
if not root.track_inventory:
return settings.MAX_CHECKOUT_LINE_QUANTITY
return AvailableQuantityByProductVariantIdAndCountryCodeLoader(
info.context).load((root.id, info.context.country))
@staticmethod
def resolve_attributes(root: models.ProductVariant, info):
return SelectedAttributesByProductVariantIdLoader(info.context).load(
root.id)
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_margin(root: models.ProductVariant, *_args):
return get_margin_for_variant(root)
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_cost_price(root: models.ProductVariant, *_args):
return root.cost_price
@staticmethod
def resolve_price(root: models.ProductVariant, *_args):
return root.base_price
@staticmethod
def resolve_pricing(root: models.ProductVariant, info):
context = info.context
product = ProductByIdLoader(context).load(root.product_id)
collections = CollectionsByProductIdLoader(context).load(
root.product_id)
def calculate_pricing_info(discounts):
def calculate_pricing_with_product(product):
def calculate_pricing_with_collections(collections):
availability = get_variant_availability(
variant=root,
product=product,
collections=collections,
discounts=discounts,
country=context.country,
local_currency=context.currency,
plugins=context.plugins,
)
return VariantPricingInfo(**asdict(availability))
return collections.then(calculate_pricing_with_collections)
return product.then(calculate_pricing_with_product)
return (DiscountsByDateTimeLoader(context).load(
info.context.request_time).then(calculate_pricing_info))
@staticmethod
def resolve_product(root: models.ProductVariant, info):
return ProductByIdLoader(info.context).load(root.product_id)
@staticmethod
def resolve_is_available(root: models.ProductVariant, info):
if not root.track_inventory:
return True
def is_variant_in_stock(available_quantity):
return available_quantity > 0
return (AvailableQuantityByProductVariantIdAndCountryCodeLoader(
info.context).load(
(root.id, info.context.country)).then(is_variant_in_stock))
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_price_override(root: models.ProductVariant, *_args):
return root.price_override
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_quantity(root: models.ProductVariant, info):
return get_available_quantity(root, info.context.country)
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_quantity_ordered(root: models.ProductVariant, *_args):
# This field is added through annotation when using the
# `resolve_report_product_sales` resolver.
return getattr(root, "quantity_ordered", None)
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_quantity_allocated(root: models.ProductVariant, info):
country = info.context.country
return get_quantity_allocated(root, country)
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_revenue(root: models.ProductVariant, *_args, period):
start_date = reporting_period_to_date(period)
return calculate_revenue_for_variant(root, start_date)
@staticmethod
def resolve_images(root: models.ProductVariant, *_args):
return root.images.all()
@classmethod
def get_node(cls, info, pk):
user = info.context.user
visible_products = models.Product.objects.visible_to_user(
user).values_list("pk", flat=True)
qs = cls._meta.model.objects.filter(product__id__in=visible_products)
return qs.filter(pk=pk).first()
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_private_meta(root: models.ProductVariant, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root: models.ProductVariant, _info):
return resolve_meta(root, _info)
@staticmethod
def __resolve_reference(root, _info, **_kwargs):
return graphene.Node.get_node_from_global_id(_info, root.id)
class PageInterface(graphene.Interface):
"""
Set basic fields exposed on every page object.
"""
id = graphene.ID()
url = graphene.String()
depth = graphene.Int()
page_type = graphene.String()
title = graphene.String()
seo_title = graphene.String()
search_description = graphene.String()
show_in_menus = graphene.Boolean()
specific = graphene.Field(lambda: PageInterface)
children = QuerySetList(lambda: PageInterface, enable_search=True)
siblings = QuerySetList(lambda: PageInterface, enable_search=True)
parent = graphene.Field(lambda: PageInterface)
next_siblings = QuerySetList(lambda: PageInterface, enable_search=True)
previous_siblings = QuerySetList(lambda: PageInterface, enable_search=True)
descendants = QuerySetList(lambda: PageInterface, enable_search=True)
ancestors = QuerySetList(lambda: PageInterface, enable_search=True)
class Meta:
description = _(
'Interface used by every GraphQL Wagtail page object type.')
def resolve_url(self, info):
"""
Resolve a path to a page.
"""
request = info.context
return self.get_url(request=request, current_site=request.site)
def resolve_page_type(self, info):
"""
Resolve a page type in a form of ``app.ModelName``.
"""
return '.'.join([
self.content_type.app_label,
self.content_type.model_class().__name__
])
def resolve_children(self, info, **kwargs):
return get_base_queryset_for_page_model_or_qs(self.get_children(),
info, **kwargs)
def resolve_descendants(self, info, **kwargs):
return get_base_queryset_for_page_model_or_qs(self.get_descendants(),
info, **kwargs)
def resolve_ancestors(self, info, **kwargs):
return get_base_queryset_for_page_model_or_qs(self.get_ancestors(),
info, **kwargs)
def resolve_siblings(self, info, **kwargs):
return get_base_queryset_for_page_model_or_qs(
self.get_siblings().exclude(pk=self.pk), info, **kwargs)
def resolve_next_siblings(self, info, **kwargs):
return get_base_queryset_for_page_model_or_qs(
self.get_next_siblings().exclude(pk=self.pk), info, **kwargs)
def resolve_previous_siblings(self, info, **kwargs):
return get_base_queryset_for_page_model_or_qs(
self.get_prev_siblings().exclude(pk=self.pk), info, **kwargs)
def resolve_parent(self, info, **kwargs):
parent = self.get_parent()
if parent is None:
return
qs = get_base_queryset_for_page_model_or_qs(Page, info, **kwargs)
try:
return qs.get(pk=parent.pk).specific
except Page.DoesNotExist:
return
def resolve_specific(self, info, **kwargs):
return self.specific
def resolve_seo_title(self, info):
"""
Get page's SEO title. Fallback to a normal page's title if absent.
"""
return self.seo_title or self.title
class Arguments: user_type = graphene.String(required=True) name = graphene.String(required=True) is_employed = graphene.Boolean(required=True) occupation = graphene.String(required=True)
class LabbookFavorite(graphene.ObjectType,
interfaces=(graphene.relay.Node, GitRepository)):
"""A type representing a file or directory that has been favorited in the labbook file system."""
# An instance of loaded favorite data
_favorite_data = None
# Section in the LabBook (code, input, output)
section = graphene.String(required=True)
# Relative path from labbook root directory.
key = graphene.String(required=True)
# Index value indicating the order of the favorite
index = graphene.Int()
# Short description about the favorite
description = graphene.String()
# The graphene type id for the associated file
associated_labbook_file_id = graphene.String()
# True indicates that the favorite is a directory
is_dir = graphene.Boolean()
def _load_favorite_info(self, dataloader):
"""Private method to retrieve file info for a given key"""
if not self._favorite_data:
# Load file info from LabBook
if not self.section or self.key is None:
raise ValueError(
"Must set `section` and `key` on object creation to resolve favorite info"
)
# Load labbook instance
lb = dataloader.load(
f"{get_logged_in_username()}&{self.owner}&{self.name}").get()
data = lb.get_favorites(self.section)
# Pull out single entry
self._favorite_data = data[self.key]
# Set class properties
self.description = self._favorite_data['description']
self.index = self._favorite_data['index']
self.is_dir = self._favorite_data['is_dir']
@classmethod
def get_node(cls, info, id):
"""Method to resolve the object based on it's Node ID"""
# Parse the key
owner, name, section, key = id.split("&")
return LabbookFavorite(id=f"{owner}&{name}&{section}&{key}",
name=name,
owner=owner,
section=section,
key=key)
def resolve_id(self, info):
"""Resolve the unique Node id for this object"""
if not self.id:
if not self.owner or not self.name or not self.section or self.key is None:
raise ValueError(
"Resolving a LabbookFavorite Node ID requires owner,name,section, and key to be set"
)
self.id = f"{self.owner}&{self.name}&{self.section}&{self.key}"
return self.id
def resolve_is_dir(self, info):
"""Resolve the is_dir field"""
if self.is_dir is None:
self._load_favorite_info(info.context.labbook_loader)
return self.is_dir
def resolve_key(self, info):
"""Resolve the is_dir field"""
if self.key is None:
self._load_favorite_info(info.context.labbook_loader)
return self.key
def resolve_index(self, info):
"""Resolve the index field"""
if self.index is None:
self._load_favorite_info(info.context.labbook_loader)
return self.index
def resolve_description(self, info):
"""Resolve the is_dir field"""
if self.description is None:
self._load_favorite_info(info.context.labbook_loader)
return self.description
def resolve_associated_labbook_file_id(self, info):
"""Resolve the associated_labbook_file_id field"""
return base64.b64encode(
f"LabbookFile:{self.owner}&{self.name}&{self.section}&{self.key}".
encode()).decode()
class Collection(CountableDjangoObjectType):
products = FilterInputConnectionField(
Product,
filter=ProductFilterInput(description="Filtering options for products."),
sort_by=ProductOrder(description="Sort products."),
description="List of products in this collection.",
)
background_image = graphene.Field(
Image, size=graphene.Int(description="Size of the image.")
)
description = graphene.String(
description="Description of the collection.",
deprecation_reason="Use the `descriptionJson` field instead.",
required=True,
)
translation = TranslationField(CollectionTranslation, type_name="collection")
is_published = graphene.Boolean(
required=True, description="Whether the collection is published."
)
class Meta:
description = "Represents a collection of products."
only_fields = [
"description_json",
"id",
"name",
"publication_date",
"seo_description",
"seo_title",
"slug",
]
interfaces = [relay.Node, ObjectWithMetadata]
model = models.Collection
@staticmethod
def resolve_background_image(root: models.Collection, info, size=None, **_kwargs):
if root.background_image:
return Image.get_adjusted(
image=root.background_image,
alt=root.background_image_alt,
size=size,
rendition_key_set="background_images",
info=info,
)
@staticmethod
def resolve_products(root: models.Collection, info, first=None, **kwargs):
return root.products.visible_to_user(info.context.user)
@classmethod
def get_node(cls, info, id):
if info.context:
requestor = get_user_or_app_from_context(info.context)
qs = cls._meta.model.objects.visible_to_user(requestor)
return qs.filter(id=id).first()
return None
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_private_meta(root: models.Collection, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root: models.Collection, _info):
return resolve_meta(root, _info)
@staticmethod
def __resolve_reference(root, _info, **_kwargs):
return graphene.Node.get_node_from_global_id(_info, root.id)
@staticmethod
def resolve_is_published(root: models.Collection, _info):
return root.is_visible
class DeleteMutation(graphene.Mutation):
class Meta:
abstract = True
id = graphene.ID()
ok = graphene.Boolean(
description="Boolean field that return mutation result request.")
errors = graphene.List(ErrorType, description="Errors list for the field")
class Arguments:
id = graphene.ID(required=True)
@classmethod
def __init_subclass_with_meta__(cls,
model=None,
interfaces=(),
resolver=None,
output=None,
arguments=None,
_meta=None,
**options):
if not _meta:
_meta = DeleteMutationOptions(cls)
assert model is not None, ("Model class in {} must be need.").format(
cls.__name__)
_meta.model = model
super(DeleteMutation,
cls).__init_subclass_with_meta__(interfaces=interfaces,
resolver=resolver,
output=output,
arguments=arguments,
_meta=_meta,
**options)
@classmethod
def get_errors(cls, errors):
errors_dict = {"ok": False, "errors": errors, "id": None}
return cls(**errors_dict)
@classmethod
def perform_mutate(cls, obj, info):
resp = {"ok": True, "errors": None, "id": obj.id}
return cls(**resp)
@classmethod
def mutate(cls, root, info, id):
try:
obj = cls._meta.model.objects.get(id=id)
obj.delete()
obj.id = id
return cls.perform_mutate(obj, info)
except ObjectDoesNotExist:
return cls.get_errors([
ErrorType(
field="id",
messages=[
"A {} obj with id {} do not exist".format(
cls._meta.model.__name__, id)
],
)
])
@classmethod
def Field(cls,
name=None,
description=None,
deprecation_reason=None,
required=False):
""" Mount instance of mutation Field. """
return Field(
cls._meta.output,
args=cls._meta.arguments,
resolver=cls._meta.resolver,
name=name,
description=description or cls._meta.description,
deprecation_reason=deprecation_reason,
required=required,
)
class AccountRegister(ModelMutation):
class Arguments:
input = AccountRegisterInput(
description="Fields required to create a user.", required=True)
requires_confirmation = graphene.Boolean(
description="Informs whether users need to confirm their email address."
)
class Meta:
description = "Register a new user."
exclude = ["password"]
model = models.User
object_type = User
error_type_class = AccountError
error_type_field = "account_errors"
@classmethod
def mutate(cls, root, info, **data):
response = super().mutate(root, info, **data)
response.requires_confirmation = settings.ENABLE_ACCOUNT_CONFIRMATION_BY_EMAIL
return response
@classmethod
def clean_input(cls, info, instance, data, input_cls=None):
data["metadata"] = {
item["key"]: item["value"]
for item in data.get("metadata") or []
}
if not settings.ENABLE_ACCOUNT_CONFIRMATION_BY_EMAIL:
return super().clean_input(info, instance, data, input_cls=None)
elif not data.get("redirect_url"):
raise ValidationError({
"redirect_url":
ValidationError("This field is required.",
code=AccountErrorCode.REQUIRED)
})
try:
validate_storefront_url(data["redirect_url"])
except ValidationError as error:
raise ValidationError({
"redirect_url":
ValidationError(error.message, code=AccountErrorCode.INVALID)
})
data["channel"] = clean_channel(data.get("channel"),
error_class=AccountErrorCode).slug
password = data["password"]
try:
password_validation.validate_password(password, instance)
except ValidationError as error:
raise ValidationError({"password": error})
data["language_code"] = data.get("language_code",
settings.LANGUAGE_CODE)
return super().clean_input(info, instance, data, input_cls=None)
@classmethod
@traced_atomic_transaction()
def save(cls, info, user, cleaned_input):
password = cleaned_input["password"]
user.set_password(password)
user.search_document = search.prepare_user_search_document_value(
user, attach_addresses_data=False)
if settings.ENABLE_ACCOUNT_CONFIRMATION_BY_EMAIL:
user.is_active = False
user.save()
notifications.send_account_confirmation(
user,
cleaned_input["redirect_url"],
info.context.plugins,
channel_slug=cleaned_input["channel"],
)
else:
user.save()
account_events.customer_account_created_event(user=user)
info.context.plugins.customer_created(customer=user)
class Query(graphene.ObjectType):
plan = gql_optimizer.field(
graphene.Field(PlanNode, id=graphene.ID(required=True)))
all_plans = graphene.List(PlanNode)
action = graphene.Field(ActionNode,
id=graphene.ID(),
identifier=graphene.ID(),
plan=graphene.ID())
indicator = graphene.Field(IndicatorNode,
id=graphene.ID(),
identifier=graphene.ID(),
plan=graphene.ID())
person = graphene.Field(PersonNode, id=graphene.ID(required=True))
static_page = graphene.Field(StaticPageNode,
plan=graphene.ID(),
slug=graphene.ID())
plan_actions = graphene.List(ActionNode,
plan=graphene.ID(required=True),
first=graphene.Int(),
order_by=graphene.String())
plan_categories = graphene.List(CategoryNode,
plan=graphene.ID(required=True))
plan_organizations = graphene.List(OrganizationNode,
plan=graphene.ID(required=True))
plan_indicators = graphene.List(
IndicatorNode,
plan=graphene.ID(required=True),
first=graphene.Int(),
order_by=graphene.String(),
has_data=graphene.Boolean(),
has_goals=graphene.Boolean(),
)
def resolve_plan(self, info, **kwargs):
qs = Plan.objects.all()
try:
plan = gql_optimizer.query(qs, info).get(identifier=kwargs['id'])
except Plan.DoesNotExist:
return None
return plan
def resolve_all_plans(self, info):
return Plan.objects.all()
def resolve_plan_actions(self,
info,
plan,
first=None,
order_by=None,
**kwargs):
qs = Action.objects.all()
qs = qs.filter(plan__identifier=plan)
qs = order_queryset(qs, ActionNode, order_by)
if first is not None:
qs = qs[0:first]
return gql_optimizer.query(qs, info)
def resolve_plan_categories(self, info, **kwargs):
qs = Category.objects.all()
plan = kwargs.get('plan')
if plan is not None:
qs = qs.filter(type__plan__identifier=plan)
return gql_optimizer.query(qs, info)
def resolve_plan_organizations(self, info, **kwargs):
qs = Organization.objects.all()
plan = kwargs.get('plan')
if plan is not None:
qs = qs.filter(
responsible_actions__action__plan__identifier=plan).distinct()
return gql_optimizer.query(qs, info)
def resolve_plan_indicators(self,
info,
plan,
first=None,
order_by=None,
has_data=None,
has_goals=None,
**kwargs):
qs = Indicator.objects.all()
qs = qs.filter(levels__plan__identifier=plan).distinct()
if has_data is not None:
qs = qs.filter(latest_value__isnull=not has_data)
if has_goals is not None:
qs = qs.filter(goals__plan__identifier=plan).distinct()
qs = order_queryset(qs, IndicatorNode, order_by)
if first is not None:
qs = qs[0:first]
return gql_optimizer.query(qs, info)
def resolve_action(self, info, **kwargs):
obj_id = kwargs.get('id')
identifier = kwargs.get('identifier')
plan = kwargs.get('plan')
if identifier and not plan:
raise Exception(
"You must supply the 'plan' argument when using 'identifier'")
qs = Action.objects.all()
if obj_id:
qs = qs.filter(id=obj_id)
if identifier:
qs = qs.filter(identifier=identifier, plan__identifier=plan)
qs = gql_optimizer.query(qs, info)
try:
obj = qs.get()
except Action.DoesNotExist:
return None
return obj
def resolve_person(self, info, **kwargs):
qs = Person.objects.all()
obj_id = kwargs.get('id')
qs = qs.filter(id=obj_id)
try:
obj = qs.get()
except Person.DoesNotExist:
return None
return obj
def resolve_indicator(self, info, **kwargs):
obj_id = kwargs.get('id')
identifier = kwargs.get('identifier')
plan = kwargs.get('plan')
if not identifier and not obj_id:
raise Exception("You must supply either 'id' or 'identifier'")
qs = Indicator.objects.all()
if obj_id:
qs = qs.filter(id=obj_id)
if plan:
qs = qs.filter(levels__plan__identifier=plan).distinct()
if identifier:
qs = qs.filter(identifier=identifier)
qs = gql_optimizer.query(qs, info)
try:
obj = qs.get()
except Indicator.DoesNotExist:
return None
return obj
def resolve_static_page(self, info, **kwargs):
slug = kwargs.get('slug')
plan = kwargs.get('plan')
if not slug or not plan:
raise Exception("You must supply both 'slug' and 'plan'")
qs = StaticPage.objects.all()
qs = qs.filter(slug=slug, plan__identifier=plan)
qs = gql_optimizer.query(qs, info)
try:
obj = qs.get()
except StaticPage.DoesNotExist:
return None
return obj
class StaffCreateInput(StaffInput):
send_password_email = graphene.Boolean(
description="Send an email with a link to set a password")
class BooleanBlock(graphene.ObjectType):
value = graphene.Boolean(required=True)
class Meta:
interfaces = (StreamFieldInterface, )
class UserCreateInput(CustomerInput):
send_password_email = graphene.Boolean(
description="Send an email with a link to set a password")
class Query(graphene.ObjectType):
# pyre-fixme[4]: Attribute must be annotated.
node = relay.Node.Field()
runs = relay.ConnectionField(RunConnection, )
issues = relay.ConnectionField(
IssueConnection,
run_id=graphene.Int(required=True),
codes=graphene.List(graphene.Int, default_value=["%"]),
paths=graphene.List(graphene.String, default_value=["%"]),
callables=MatchesIsField(),
source_names=MatchesIsField(),
source_kinds=MatchesIsField(),
sink_names=MatchesIsField(),
sink_kinds=MatchesIsField(),
statuses=graphene.List(graphene.String, default_value=["%"]),
features=graphene.List(FeatureCondition),
min_trace_length_to_sinks=graphene.Int(),
max_trace_length_to_sinks=graphene.Int(),
min_trace_length_to_sources=graphene.Int(),
max_trace_length_to_sources=graphene.Int(),
issue_instance_id=graphene.Int(),
is_new_issue=graphene.Boolean(),
)
trace = relay.ConnectionField(TraceFrameConnection,
issue_instance_id=graphene.ID())
initial_trace_frames = relay.ConnectionField(
TraceFrameConnection,
issue_instance_id=graphene.Int(),
kind=graphene.String())
next_trace_frames = relay.ConnectionField(
TraceFrameConnection,
issue_instance_id=graphene.Int(),
frame_id=graphene.Int(),
kind=graphene.String(),
)
# Typeahead data.
codes = relay.ConnectionField(CodeConnection)
paths = relay.ConnectionField(PathConnection)
callables = relay.ConnectionField(CallableConnection)
features = relay.ConnectionField(FeatureConnection)
source_names = relay.ConnectionField(SourceNameConnection)
source_kinds = relay.ConnectionField(SourceKindConnection)
sink_names = relay.ConnectionField(SinkNameConnection)
sink_kinds = relay.ConnectionField(SinkKindConnection)
statuses = relay.ConnectionField(StatusConnection)
file = relay.ConnectionField(FileConnection, path=graphene.String())
filters = relay.ConnectionField(FilterConnection)
def resolve_runs(self, info: ResolveInfo) -> List[run.Run]:
session = get_session(info.context)
return run.runs(session)
def resolve_issues(
self,
info: ResolveInfo,
run_id: int,
codes: List[int],
paths: List[str],
statuses: List[str],
callables: Optional[MatchesIsField] = None,
features: Optional[List[FeatureCondition]] = None,
min_trace_length_to_sinks: Optional[int] = None,
max_trace_length_to_sinks: Optional[int] = None,
min_trace_length_to_sources: Optional[int] = None,
max_trace_length_to_sources: Optional[int] = None,
issue_instance_id: Optional[int] = None,
is_new_issue: Optional[bool] = None,
source_names: Optional[MatchesIsField] = None,
source_kinds: Optional[MatchesIsField] = None,
sink_names: Optional[MatchesIsField] = None,
sink_kinds: Optional[MatchesIsField] = None,
**kwargs: Any,
) -> List[IssueQueryResult]:
session = get_session(info.context)
filter_instance = Filter.from_query(
codes,
paths,
callables,
statuses,
source_names,
source_kinds,
sink_names,
sink_kinds,
features,
min_trace_length_to_sinks,
max_trace_length_to_sinks,
min_trace_length_to_sources,
max_trace_length_to_sources,
is_new_issue,
)
issues = (Instance(session,
DBID(run_id)).where_filter(filter_instance).
where_issue_instance_id_is(issue_instance_id).get())
return issues
def resolve_initial_trace_frames(self, info: ResolveInfo,
issue_instance_id: int,
kind: str) -> List[TraceFrameQueryResult]:
session = info.context.get("session")
return trace.initial_frames(session, DBID(issue_instance_id),
TraceKind.create_from_string(kind))
def resolve_next_trace_frames(self, info: ResolveInfo,
issue_instance_id: int, frame_id: int,
kind: str) -> List[TraceFrameQueryResult]:
session = info.context.get("session")
trace_kind = TraceKind.create_from_string(kind)
if trace_kind == TraceKind.POSTCONDITION:
leaf_kind = issues.sources(session, DBID(issue_instance_id))
elif trace_kind == TraceKind.PRECONDITION:
leaf_kind = issues.sinks(session, DBID(issue_instance_id))
trace_frame = session.query(TraceFrame).get(frame_id)
if trace_frame is None:
raise ValueError(f"`{frame_id}` is not a valid trace frame id")
return trace.next_frames(
session,
trace_frame,
# pyre-fixme[61]: `leaf_kind` may not be initialized here.
leaf_kind,
visited_ids=set(),
)
def resolve_codes(self, info: ResolveInfo) -> List[typeahead.Code]:
session = info.context["session"]
return typeahead.all_codes(session)
def resolve_paths(self, info: ResolveInfo) -> List[typeahead.Path]:
session = info.context["session"]
return typeahead.all_paths(session)
def resolve_callables(self, info: ResolveInfo) -> List[typeahead.Callable]:
session = info.context["session"]
return typeahead.all_callables(session)
def resolve_source_names(self,
info: ResolveInfo) -> List[typeahead.SourceName]:
session = info.context["session"]
return typeahead.all_source_names(session)
def resolve_source_kinds(self,
info: ResolveInfo) -> List[typeahead.SourceName]:
session = info.context["session"]
return typeahead.all_source_kinds(session)
def resolve_sink_names(self,
info: ResolveInfo) -> List[typeahead.SourceName]:
session = info.context["session"]
return typeahead.all_sink_names(session)
def resolve_sink_kinds(self,
info: ResolveInfo) -> List[typeahead.SourceName]:
session = info.context["session"]
return typeahead.all_sink_kinds(session)
def resolve_statuses(self, info: ResolveInfo) -> List[typeahead.Status]:
session = info.context["session"]
return typeahead.all_statuses(session)
def resolve_features(self, info: ResolveInfo) -> List[typeahead.Feature]:
session = info.context["session"]
return typeahead.all_features(session)
def resolve_file(self, info: ResolveInfo, path: str,
**kwargs: Any) -> List[File]:
if ".." in path:
raise FileNotFoundError("Attempted directory traversal")
source_directory = Path(
info.context.get("source_directory") or os.getcwd())
full_path = source_directory / path
contents = full_path.read_text()
editor_link = None
editor_schema = info.context.get("editor_schema")
if editor_schema is not None:
editor_link = f"{editor_schema}//file/{str(full_path)}"
return [File(path=path, contents=contents, editor_link=editor_link)]
def resolve_filters(self,
info: ResolveInfo) -> List[filters_module.Filter]:
session = info.context["session"]
return filters_module.all_filters(session)
class Order(MetadataObjectType, CountableDjangoObjectType):
fulfillments = gql_optimizer.field(
graphene.List(Fulfillment,
required=True,
description="List of shipments for the order."),
model_field="fulfillments",
)
lines = gql_optimizer.field(
graphene.List(lambda: OrderLine,
required=True,
description="List of order lines."),
model_field="lines",
)
actions = graphene.List(
OrderAction,
description=
("List of actions that can be performed in the current state of an order."
),
required=True,
)
available_shipping_methods = graphene.List(
ShippingMethod,
required=False,
description="Shipping methods that can be used with this order.",
)
number = graphene.String(description="User-friendly number of an order.")
is_paid = graphene.Boolean(
description="Informs if an order is fully paid.")
payment_status = PaymentChargeStatusEnum(
description="Internal payment status.")
payment_status_display = graphene.String(
description="User-friendly payment status.")
payments = gql_optimizer.field(
graphene.List(Payment, description="List of payments for the order."),
model_field="payments",
)
total = graphene.Field(TaxedMoney,
description="Total amount of the order.")
shipping_price = graphene.Field(TaxedMoney,
description="Total price of shipping.")
subtotal = graphene.Field(
TaxedMoney,
description="The sum of line prices not including shipping.")
gift_cards = gql_optimizer.field(
graphene.List(GiftCard, description="List of user gift cards."),
model_field="gift_cards",
)
status_display = graphene.String(description="User-friendly order status.")
can_finalize = graphene.Boolean(
description=("Informs whether a draft order can be finalized"
"(turned into a regular order)."),
required=True,
)
total_authorized = graphene.Field(
Money, description="Amount authorized for the order.")
total_captured = graphene.Field(Money,
description="Amount captured by payment.")
events = gql_optimizer.field(
graphene.List(OrderEvent,
description="List of events associated with the order."),
model_field="events",
)
total_balance = graphene.Field(
Money,
description=
"The difference between the paid and the order total amount.",
required=True,
)
user_email = graphene.String(required=False,
description="Email address of the customer.")
is_shipping_required = graphene.Boolean(
description="Returns True, if order requires shipping.", required=True)
class Meta:
description = "Represents an order in the shop."
interfaces = [relay.Node]
model = models.Order
only_fields = [
"billing_address",
"created",
"customer_note",
"discount",
"discount_name",
"display_gross_prices",
"gift_cards",
"id",
"language_code",
"shipping_address",
"shipping_method",
"shipping_method_name",
"shipping_price",
"status",
"token",
"tracking_client_id",
"translated_discount_name",
"user",
"voucher",
"weight",
]
@staticmethod
def resolve_shipping_price(root: models.Order, _info):
return root.shipping_price
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="payments__transactions")
def resolve_actions(root: models.Order, _info):
actions = []
payment = root.get_last_payment()
if root.can_capture(payment):
actions.append(OrderAction.CAPTURE)
if root.can_mark_as_paid():
actions.append(OrderAction.MARK_AS_PAID)
if root.can_refund(payment):
actions.append(OrderAction.REFUND)
if root.can_void(payment):
actions.append(OrderAction.VOID)
return actions
@staticmethod
def resolve_subtotal(root: models.Order, _info):
return root.get_subtotal()
@staticmethod
def resolve_total(root: models.Order, _info):
return root.total
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="payments__transactions")
def resolve_total_authorized(root: models.Order, _info):
# FIXME adjust to multiple payments in the future
return root.total_authorized
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="payments")
def resolve_total_captured(root: models.Order, _info):
# FIXME adjust to multiple payments in the future
return root.total_captured
@staticmethod
def resolve_total_balance(root: models.Order, _info):
return root.total_balance
@staticmethod
def resolve_fulfillments(root: models.Order, info):
user = info.context.user
if user.is_staff:
qs = root.fulfillments.all()
else:
qs = root.fulfillments.exclude(status=FulfillmentStatus.CANCELED)
return qs.order_by("pk")
@staticmethod
def resolve_lines(root: models.Order, _info):
return root.lines.all().order_by("pk")
@staticmethod
def resolve_events(root: models.Order, _info):
return root.events.all().order_by("pk")
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="payments")
def resolve_is_paid(root: models.Order, _info):
return root.is_fully_paid()
@staticmethod
def resolve_number(root: models.Order, _info):
return str(root.pk)
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="payments")
def resolve_payment_status(root: models.Order, _info):
return root.get_payment_status()
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="payments")
def resolve_payment_status_display(root: models.Order, _info):
return root.get_payment_status_display()
@staticmethod
def resolve_payments(root: models.Order, _info):
return root.payments.all()
@staticmethod
def resolve_status_display(root: models.Order, _info):
return root.get_status_display()
@staticmethod
def resolve_can_finalize(root: models.Order, _info):
try:
validate_draft_order(root)
except ValidationError:
return False
return True
@staticmethod
@gql_optimizer.resolver_hints(select_related="user")
def resolve_user_email(root: models.Order, _info):
return root.get_customer_email()
@staticmethod
def resolve_available_shipping_methods(root: models.Order, _info):
available = get_valid_shipping_methods_for_order(root)
if available is None:
return []
manager = get_extensions_manager()
display_gross = display_gross_prices()
for shipping_method in available:
# Ignore typing check because it is checked in
# get_valid_shipping_methods_for_order
taxed_price = manager.apply_taxes_to_shipping(
shipping_method.price,
root.shipping_address # type: ignore
)
if display_gross:
shipping_method.price = taxed_price.gross
else:
shipping_method.price = taxed_price.net
return available
@staticmethod
def resolve_is_shipping_required(root: models.Order, _info):
return root.is_shipping_required()
@staticmethod
def resolve_gift_cards(root: models.Order, _info):
return root.gift_cards.all()
@staticmethod
@permission_required(OrderPermissions.MANAGE_ORDERS)
def resolve_private_meta(root: models.Order, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root: models.Order, _info):
return resolve_meta(root, _info)
class LegalContents(graphene.ObjectType):
__doc__ = docs.LegalContents.__doc__
legal_notice = graphene.String(lang=graphene.String(),
description=docs.LegalContents.legal_notice)
terms_and_conditions = graphene.String(
lang=graphene.String(),
description=docs.LegalContents.terms_and_conditions)
legal_notice_entries = graphene.List(
LangStringEntry, description=docs.LegalContents.legal_notice_entries)
terms_and_conditions_entries = graphene.List(
LangStringEntry,
description=docs.LegalContents.terms_and_conditions_entries)
cookies_policy = graphene.String(
lang=graphene.String(), description=docs.LegalContents.cookies_policy)
privacy_policy = graphene.String(
lang=graphene.String(), description=docs.LegalContents.privacy_policy)
cookies_policy_entries = graphene.List(
LangStringEntry, description=docs.LegalContents.cookies_policy_entries)
privacy_policy_entries = graphene.List(
LangStringEntry, description=docs.LegalContents.privacy_policy_entries)
user_guidelines = graphene.String(
lang=graphene.String(), description=docs.LegalContents.user_guidelines)
user_guidelines_entries = graphene.List(
LangStringEntry,
description=docs.LegalContents.user_guidelines_entries)
legal_notice_attachments = graphene.List(
Attachment, description=docs.LegalContents.legal_notice_attachments)
terms_and_conditions_attachments = graphene.List(
Attachment,
description=docs.LegalContents.terms_and_conditions_attachments)
cookies_policy_attachments = graphene.List(
Attachment, description=docs.LegalContents.cookies_policy_attachments)
privacy_policy_attachments = graphene.List(
Attachment, description=docs.LegalContents.privacy_policy_attachments)
user_guidelines_attachments = graphene.List(
Attachment, description=docs.LegalContents.user_guidelines_attachments)
mandatory_legal_contents_validation = graphene.Boolean(
required=True,
description=docs.LegalContents.mandatory_legal_contents_validation)
def resolve_legal_notice(self, args, context, info):
"""Legal notice value in given locale."""
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return resolve_langstring(discussion.legal_notice, args.get('lang'))
def resolve_terms_and_conditions(self, args, context, info):
"""Terms and conditions value in given locale."""
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return resolve_langstring(discussion.terms_and_conditions,
args.get('lang'))
def resolve_legal_notice_entries(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
if discussion.legal_notice:
return resolve_langstring_entries(discussion, 'legal_notice')
return []
def resolve_terms_and_conditions_entries(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
if discussion.terms_and_conditions:
return resolve_langstring_entries(discussion,
'terms_and_conditions')
return []
def resolve_cookies_policy(self, args, context, info):
"""Cookies policy value in given locale."""
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return resolve_langstring(discussion.cookies_policy, args.get('lang'))
def resolve_privacy_policy(self, args, context, info):
"""Privacy policy value in given locale."""
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return resolve_langstring(discussion.privacy_policy, args.get('lang'))
def resolve_cookies_policy_entries(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
if discussion.cookies_policy:
return resolve_langstring_entries(discussion, 'cookies_policy')
return []
def resolve_privacy_policy_entries(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
if discussion.privacy_policy:
return resolve_langstring_entries(discussion, 'privacy_policy')
return []
def resolve_user_guidelines(self, args, context, info):
"""User guidelines value in given locale."""
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return resolve_langstring(discussion.user_guidelines, args.get('lang'))
def resolve_user_guidelines_entries(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
if discussion.user_guidelines:
return resolve_langstring_entries(discussion, 'user_guidelines')
return []
def resolve_legal_notice_attachments(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return get_attachments_with_purpose(
discussion.attachments,
models.AttachmentPurpose.LEGAL_NOTICE_ATTACHMENT.value)
def resolve_terms_and_conditions_attachments(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return get_attachments_with_purpose(
discussion.attachments,
models.AttachmentPurpose.TERMS_AND_CONDITIONS_ATTACHMENT.value)
def resolve_cookies_policy_attachments(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return get_attachments_with_purpose(
discussion.attachments,
models.AttachmentPurpose.COOKIES_POLICY_ATTACHMENT.value)
def resolve_privacy_policy_attachments(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return get_attachments_with_purpose(
discussion.attachments,
models.AttachmentPurpose.PRIVACY_POLICY_ATTACHMENT.value)
def resolve_user_guidelines_attachments(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return get_attachments_with_purpose(
discussion.attachments,
models.AttachmentPurpose.USER_GUIDELINES_ATTACHMENT.value)
def resolve_mandatory_legal_contents_validation(self, args, context, info):
discussion_id = context.matchdict['discussion_id']
discussion = models.Discussion.get(discussion_id)
return discussion.preferences['mandatory_legal_contents_validation']
class Arguments:
note_id = graphene.UUID(required=True, name='id')
ultimate = graphene.Boolean(name='ultimate')
class Arguments:
follow_request_id = graphene.String(
required=True, description="Follow request identifier")
approved = graphene.Boolean(description="Approve or reject follow")
class Product(CountableDjangoObjectType):
url = graphene.String(
description="The storefront URL for the product.", required=True
)
thumbnail_url = graphene.String(
description="The URL of a main thumbnail for a product.",
size=graphene.Argument(graphene.Int, description="Size of thumbnail"),
deprecation_reason=(
"""thumbnailUrl is deprecated, use
thumbnail instead"""
),
)
thumbnail = graphene.Field(
Image,
description="The main thumbnail for a product.",
size=graphene.Argument(graphene.Int, description="Size of thumbnail"),
)
availability = graphene.Field(
ProductPricingInfo,
description="""Informs about product's availability in the
storefront, current price and discounts.""",
deprecation_reason="Has been renamed to 'pricing'.",
)
pricing = graphene.Field(
ProductPricingInfo,
description="""Lists the storefront product's pricing,
the current price and discounts, only meant for displaying.""",
)
is_available = graphene.Boolean(
description="Whether the product is in stock and visible or not."
)
base_price = graphene.Field(Money, description="The product's default base price.")
price = graphene.Field(
Money,
description="The product's default base price.",
deprecation_reason=("Has been replaced by 'basePrice'"),
)
tax_rate = TaxRateType(
description="A type of tax rate.",
deprecation_reason=(
"taxRate is deprecated. Use taxType to obtain taxCode for given tax gateway"
),
)
tax_type = graphene.Field(
TaxType, description="A type of tax. Assigned by enabled tax gateway"
)
attributes = graphene.List(
graphene.NonNull(SelectedAttribute),
required=True,
description="List of attributes assigned to this product.",
)
purchase_cost = graphene.Field(MoneyRange)
margin = graphene.Field(Margin)
image_by_id = graphene.Field(
lambda: ProductImage,
id=graphene.Argument(graphene.ID, description="ID of a product image."),
description="Get a single product image by ID",
)
variants = gql_optimizer.field(
graphene.List(ProductVariant, description="List of variants for the product"),
model_field="variants",
)
images = gql_optimizer.field(
graphene.List(
lambda: ProductImage, description="List of images for the product"
),
model_field="images",
)
collections = gql_optimizer.field(
graphene.List(
lambda: Collection, description="List of collections for the product"
),
model_field="collections",
)
available_on = graphene.Date(
deprecation_reason=("availableOn is deprecated, use publicationDate instead")
)
translation = graphene.Field(
ProductTranslation,
language_code=graphene.Argument(
LanguageCodeEnum,
description="A language code to return the translation for.",
required=True,
),
description=("Returns translated Product fields for the given language code."),
resolver=resolve_translation,
)
class Meta:
description = """Represents an individual item for sale in the
storefront."""
interfaces = [relay.Node]
model = models.Product
only_fields = [
"category",
"charge_taxes",
"description",
"description_json",
"id",
"is_published",
"name",
"product_type",
"publication_date",
"seo_description",
"seo_title",
"updated_at",
"weight",
]
@staticmethod
def resolve_tax_rate(root: models.Product, _info, **_kwargs):
# FIXME this resolver should be dropped after we drop tax_rate from API
tax_rate = vatlayer_interface.get_tax_from_object_meta(root).code
return tax_rate or None
@staticmethod
def resolve_tax_type(root: models.Product, _info):
tax_data = tax_interface.get_tax_from_object_meta(root)
return TaxType(tax_code=tax_data.code, description=tax_data.description)
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="images")
def resolve_thumbnail_url(root: models.Product, info, *, size=None):
if not size:
size = 255
url = get_product_image_thumbnail(
root.get_first_image(), size, method="thumbnail"
)
return info.context.build_absolute_uri(url)
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="images")
def resolve_thumbnail(root: models.Product, info, *, size=None):
image = root.get_first_image()
if not size:
size = 255
url = get_product_image_thumbnail(image, size, method="thumbnail")
url = info.context.build_absolute_uri(url)
alt = image.alt if image else None
return Image(alt=alt, url=url)
@staticmethod
def resolve_url(root: models.Product, *_args):
return root.get_absolute_url()
@staticmethod
@gql_optimizer.resolver_hints(
prefetch_related=("variants", "collections"),
only=["publication_date", "charge_taxes", "price", "meta"],
)
def resolve_pricing(root: models.Product, info):
context = info.context
availability = get_product_availability(
root, context.discounts, context.country, context.currency, context.taxes
)
return ProductPricingInfo(**availability._asdict())
resolve_availability = resolve_pricing
@staticmethod
def resolve_is_available(root: models.Product, _info):
return root.is_available
@staticmethod
@permission_required("product.manage_products")
def resolve_base_price(root: models.Product, _info):
return root.price
@staticmethod
@gql_optimizer.resolver_hints(
prefetch_related=("variants", "collections"),
only=["publication_date", "charge_taxes", "price", "meta"],
)
def resolve_price(root: models.Product, info):
price_range = root.get_price_range(info.context.discounts)
price = tax_interface.apply_taxes_to_product(
root, price_range.start, info.context.country, taxes=info.context.taxes
)
return price.net
@staticmethod
@gql_optimizer.resolver_hints(
prefetch_related="product_type__product_attributes__values"
)
def resolve_attributes(root: models.Product, *_args):
attributes_qs = root.product_type.product_attributes.all()
return resolve_attribute_list(root.attributes, attributes_qs)
@staticmethod
@permission_required("product.manage_products")
def resolve_purchase_cost(root: models.Product, *_args):
purchase_cost, _ = get_product_costs_data(root)
return purchase_cost
@staticmethod
@permission_required("product.manage_products")
def resolve_margin(root: models.Product, *_args):
_, margin = get_product_costs_data(root)
return Margin(margin[0], margin[1])
@staticmethod
def resolve_image_by_id(root: models.Product, info, id):
pk = get_database_id(info, id, ProductImage)
try:
return root.images.get(pk=pk)
except models.ProductImage.DoesNotExist:
raise GraphQLError("Product image not found.")
@staticmethod
@gql_optimizer.resolver_hints(model_field="images")
def resolve_images(root: models.Product, *_args, **_kwargs):
return root.images.all()
@staticmethod
def resolve_variants(root: models.Product, *_args, **_kwargs):
return root.variants.all()
@staticmethod
def resolve_collections(root: models.Product, *_args):
return root.collections.all()
@staticmethod
def resolve_available_on(root: models.Product, *_args):
return root.publication_date
@classmethod
def get_node(cls, info, pk):
if info.context:
qs = cls._meta.model.objects.visible_to_user(info.context.user)
return cls.maybe_optimize(info, qs, pk)
return None
class Arguments:
identifier = graphene.String(required=False)
service = graphene.String(required=True)
spf_identifier = graphene.String(required=False)
share_spf = graphene.Boolean(required=True)
class Query(graphene.ObjectType):
offers = graphene.List(of_type=GraphQL_offer)
users = graphene.List(of_type=GraphQL_user)
# API rewrite methods
user = graphene.Field(GraphQL_user,
userID=graphene.String(default_value="none"))
offer = graphene.Field(GraphQL_offer,
offerID=graphene.Int(default_value=-1))
mineCoinCoins = graphene.Field(
GraphQL_user, userID=graphene.String(default_value="none"))
transaction = graphene.Boolean(offerID=graphene.Int(),
userID=graphene.String())
cancelOffer = graphene.Boolean(offerID=graphene.Int())
# API Rewrite Methods
def resolve_mineCoinCoins(self, info, userID):
user = User.query.filter_by(userID=userID).first()
newCoinVal = user.coin_val + 1
user.coin_val = newCoinVal
db.session.commit()
return GraphQL_user(userID=user.userID,
displayName=user.display_name,
email=user.email,
coinVal=user.coin_val)
def resolve_transaction(self, info, offerID, userID):
offer = Offer.query.filter_by(offerID=offerID).first()
user = User.query.filter_by(userID=userID).first()
coinCoins = offer.coinCoinOffer
currentCoinVal = user.coin_val
user.coin_val = currentCoinVal + coinCoins
db.session.delete(offer)
db.session.commit()
return True
def resolve_cancelOffer(self, info, offerID):
offer = Offer.query.filter_by(offerID=offerID).first()
db.session.delete(offer)
db.session.commit()
return True
def resolve_offer(self, info, offerID):
offer = Offer.query.filter_by(offerID=offerID).first()
return GraphQL_offer(offerID=offer.offerID,
USD_Offer=offer.USDOffer,
coin_Offer=offer.coinCoinOffer,
userID=offer.userID,
displayName=offer.display_name)
def resolve_offers(self, info):
offers_query = Offer.query.all()
if offers_query is not None:
offers = [
GraphQL_offer(offerID=offer.offerID,
USD_Offer=offer.USDOffer,
coin_Offer=offer.coinCoinOffer,
userID=offer.userID,
displayName=offer.display_name)
for offer in offers_query
]
else:
offers = []
return offers
def resolve_user(self, info, userID):
user = User.query.filter_by(userID=userID).first()
if user is not None:
offers_query = Offer.query.filter_by(userID=userID).all()
if offers_query is not None:
offers = [
GraphQL_offer(offerID=offer.offerID,
USD_Offer=offer.USDOffer,
coin_Offer=offer.coinCoinOffer,
userID=offer.userID,
displayName=offer.display_name)
for offer in offers_query
]
else:
offers = []
return GraphQL_user(userID=user.userID,
displayName=user.display_name,
email=user.email,
coinVal=user.coin_val,
offers=offers)
else:
return {}
# i am so proud of this function like im a genius
def resolve_users(self, info):
users_query = db.session.query(User, Offer).outerjoin(Offer).all()
if users_query is not None:
users = [
GraphQL_user(userID=join[0].userID,
displayName=join[0].display_name,
email=join[0].email,
coinVal=join[0].coin_val,
offers=[
GraphQL_offer(offerID=offer.offerID,
USD_Offer=offer.USDOffer,
coin_Offer=offer.coinCoinOffer,
userID=offer.userID,
displayName=offer.display_name)
for offer in join if type(offer) is Offer
]) for join in users_query
]
else:
users = []
return users
class FoodType(DjangoObjectType):
total_products = graphene.Int()
url = graphene.String()
in_used_by_store = graphene.Boolean()
class Meta:
model = Type
class Checkout(MetadataObjectType, CountableDjangoObjectType):
available_shipping_methods = graphene.List(
ShippingMethod,
required=True,
description="Shipping methods that can be used with this order.",
)
available_payment_gateways = graphene.List(
PaymentGateway,
description="List of available payment gateways.",
required=True)
email = graphene.String(description="Email of a customer.", required=True)
gift_cards = gql_optimizer.field(
graphene.List(
GiftCard,
description="List of gift cards associated with this checkout."),
model_field="gift_cards",
)
is_shipping_required = graphene.Boolean(
description="Returns True, if checkout requires shipping.",
required=True)
lines = gql_optimizer.field(
graphene.List(
CheckoutLine,
description=(
"A list of checkout lines, each containing information about "
"an item in the checkout."),
),
model_field="lines",
)
shipping_price = graphene.Field(
TaxedMoney,
description="The price of the shipping, with all the taxes included.",
)
subtotal_price = graphene.Field(
TaxedMoney,
description=
"The price of the checkout before shipping, with taxes included.",
)
total_price = graphene.Field(
TaxedMoney,
description=(
"The sum of the the checkout line prices, with all the taxes,"
"shipping costs, and discounts included."),
)
class Meta:
only_fields = [
"billing_address",
"created",
"discount_name",
"gift_cards",
"is_shipping_required",
"last_change",
"note",
"quantity",
"shipping_address",
"shipping_method",
"token",
"translated_discount_name",
"user",
"voucher_code",
"discount",
]
description = "Checkout object."
model = models.Checkout
interfaces = [graphene.relay.Node]
filter_fields = ["token"]
@staticmethod
def resolve_email(root: models.Checkout, info):
return root.get_customer_email()
@staticmethod
def resolve_total_price(root: models.Checkout, info):
taxed_total = (calculations.checkout_total(
checkout=root, discounts=info.context.discounts) -
root.get_total_gift_cards_balance())
return max(taxed_total, zero_taxed_money())
@staticmethod
def resolve_subtotal_price(root: models.Checkout, info):
return calculations.checkout_subtotal(checkout=root,
discounts=info.context.discounts)
@staticmethod
def resolve_shipping_price(root: models.Checkout, info):
return calculations.checkout_shipping_price(
checkout=root, discounts=info.context.discounts)
@staticmethod
def resolve_lines(root: models.Checkout, *_args):
return root.lines.prefetch_related("variant")
@staticmethod
def resolve_available_shipping_methods(root: models.Checkout, info):
available = get_valid_shipping_methods_for_checkout(
root, info.context.discounts)
if available is None:
return []
manager = get_extensions_manager()
display_gross = display_gross_prices()
for shipping_method in available:
# ignore mypy checking because it is checked in
# get_valid_shipping_methods_for_checkout
taxed_price = manager.apply_taxes_to_shipping(
shipping_method.price,
root.shipping_address # type: ignore
)
if display_gross:
shipping_method.price = taxed_price.gross
else:
shipping_method.price = taxed_price.net
return available
@staticmethod
def resolve_available_payment_gateways(_: models.Checkout, _info):
return [
gtw for gtw in get_extensions_manager().list_payment_gateways()
]
@staticmethod
def resolve_gift_cards(root: models.Checkout, _info):
return root.gift_cards.all()
@staticmethod
def resolve_is_shipping_required(root: models.Checkout, _info):
return root.is_shipping_required()
@staticmethod
@permission_required(OrderPermissions.MANAGE_ORDERS)
def resolve_private_meta(root: models.Checkout, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root: models.Checkout, _info):
return resolve_meta(root, _info)
class SpaceContract(graphene.Mutation):
"""
Mutation to Space Contract
"""
class Arguments:
startDate = graphene.String(required=True)
endDate = graphene.String(required=True)
spaceId = graphene.String(required=True)
order = graphene.List(graphene.String)
success = graphene.Boolean()
errors = graphene.List(ErrorsType)
space = graphene.Field(SpaceType)
contract_spaces = DjangoFilterConnectionField(SpaceType, )
@staticmethod
def mutate(_, info, **kwargs):
try:
start_date = string_to_date(kwargs.get('startDate'))
end_date = string_to_date(kwargs.get('endDate'))
space_id = kwargs.get('spaceId')
token = get_auth_token(info.context)
account_token = AccountToken.get_account({'token': token})
if account_token is None:
return SpaceContract(
success=False,
errors=[ErrorsType(field='token', message='トークンが無効です。')])
if account_token.expire < datetime.now():
account_token.delete()
return SpaceContract(
success=False,
errors=[ErrorsType(field='expired', message='期限切れです。')])
space = Space.get_empty_space_by_id(space_id)
if space is None:
return SpaceContract(
success=False,
errors=[ErrorsType(field='space', message='既に契約してます。')])
space.contract_status = True
space.contract_start = start_date
space.contract_end = end_date
space.account = account_token.account
space.save()
order = kwargs.get('order')
if order is None:
order = ['-created_date']
contract_spaces = Space.get_spaces({
'account':
account_token.account,
'contract_end__gte':
datetime.now(),
}).order_by(*order)
return SpaceContract(
success=True,
space=space,
contract_spaces=contract_spaces,
)
except Exception as e:
return SpaceContract(
success=False,
errors=[ErrorsType(field='exception', message=str(e))])
class ProductVariant(CountableDjangoObjectType, MetadataObjectType):
stock_quantity = graphene.Int(
required=True, description="Quantity of a product available for sale.")
price_override = graphene.Field(
Money,
description=
("Override the base price of a product if necessary. A value of `null` "
"indicates that the default product price is used."),
)
price = graphene.Field(
Money,
description="Price of the product variant.",
deprecation_reason=(
"DEPRECATED: Will be removed in Saleor 2.10, "
"has been replaced by 'pricing.priceUndiscounted'"),
)
availability = graphene.Field(
VariantPricingInfo,
description=
("Informs about variant's availability in the storefront, current price and "
"discounted price."),
deprecation_reason=
("DEPRECATED: Will be removed in Saleor 2.10, has been renamed to `pricing`."
),
)
pricing = graphene.Field(
VariantPricingInfo,
description=
("Lists the storefront variant's pricing, the current price and discounts, "
"only meant for displaying."),
)
is_available = graphene.Boolean(
description="Whether the variant is in stock and visible or not.")
attributes = gql_optimizer.field(
graphene.List(
graphene.NonNull(SelectedAttribute),
required=True,
description="List of attributes assigned to this variant.",
))
cost_price = graphene.Field(Money,
description="Cost price of the variant.")
margin = graphene.Int(description="Gross margin percentage value.")
quantity_ordered = graphene.Int(description="Total quantity ordered.")
revenue = graphene.Field(
TaxedMoney,
period=graphene.Argument(ReportingPeriod),
description=
("Total revenue generated by a variant in given period of time. Note: this "
"field should be queried using `reportProductSales` query as it uses "
"optimizations suitable for such calculations."),
)
images = gql_optimizer.field(
graphene.List(lambda: ProductImage,
description="List of images for the product variant."),
model_field="images",
)
translation = graphene.Field(
ProductVariantTranslation,
language_code=graphene.Argument(
LanguageCodeEnum,
description="A language code to return the translation for.",
required=True,
),
description=("Returns translated Product Variant fields "
"for the given language code."),
resolver=resolve_translation,
)
digital_content = gql_optimizer.field(
graphene.Field(DigitalContent,
description="Digital content for the product variant."),
model_field="digital_content",
)
class Meta:
description = (
"Represents a version of a product such as different size or color."
)
only_fields = [
"id",
"name",
"product",
"quantity",
"quantity_allocated",
"sku",
"track_inventory",
"weight",
]
interfaces = [relay.Node]
model = models.ProductVariant
@staticmethod
@permission_required("product.manage_products")
def resolve_digital_content(root: models.ProductVariant, *_args):
return getattr(root, "digital_content", None)
@staticmethod
def resolve_stock_quantity(root: models.ProductVariant, *_args):
return root.quantity_available
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related=[
"attributes__values", "attributes__assignment__attribute"
])
def resolve_attributes(root: models.ProductVariant, info):
return resolve_attribute_list(root, user=info.context.user)
@staticmethod
@permission_required("product.manage_products")
def resolve_margin(root: models.ProductVariant, *_args):
return get_margin_for_variant(root)
@staticmethod
def resolve_price(root: models.ProductVariant, *_args):
return (root.price_override
if root.price_override is not None else root.product.price)
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related=("product", ),
only=["price_override_amount", "currency"])
def resolve_pricing(root: models.ProductVariant, info):
context = info.context
availability = get_variant_availability(
root,
context.discounts,
context.country,
context.currency,
extensions=context.extensions,
)
return VariantPricingInfo(**availability._asdict())
resolve_availability = resolve_pricing
@staticmethod
def resolve_is_available(root: models.ProductVariant, _info):
return root.is_available
@staticmethod
@permission_required("product.manage_products")
def resolve_price_override(root: models.ProductVariant, *_args):
return root.price_override
@staticmethod
@permission_required("product.manage_products")
def resolve_quantity(root: models.ProductVariant, *_args):
return root.quantity
@staticmethod
@permission_required(["order.manage_orders", "product.manage_products"])
def resolve_quantity_ordered(root: models.ProductVariant, *_args):
# This field is added through annotation when using the
# `resolve_report_product_sales` resolver.
return getattr(root, "quantity_ordered", None)
@staticmethod
@permission_required(["order.manage_orders", "product.manage_products"])
def resolve_quantity_allocated(root: models.ProductVariant, *_args):
return root.quantity_allocated
@staticmethod
@permission_required(["order.manage_orders", "product.manage_products"])
def resolve_revenue(root: models.ProductVariant, *_args, period):
start_date = reporting_period_to_date(period)
return calculate_revenue_for_variant(root, start_date)
@staticmethod
def resolve_images(root: models.ProductVariant, *_args):
return root.images.all()
@classmethod
def get_node(cls, info, id):
user = info.context.user
visible_products = models.Product.objects.visible_to_user(
user).values_list("pk", flat=True)
qs = cls._meta.model.objects.filter(product__id__in=visible_products)
return cls.maybe_optimize(info, qs, id)
@staticmethod
@permission_required("product.manage_products")
def resolve_private_meta(root, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root, _info):
return resolve_meta(root, _info)
class LabbookFile(graphene.ObjectType,
interfaces=(graphene.relay.Node, GitRepository)):
"""A type representing a file or directory inside the labbook file system."""
# Loaded file info
_file_info = None
# Section in the LabBook (code, input, output)
section = graphene.String(required=True)
# Relative path from labbook section.
key = graphene.String(required=True)
# True indicates that path points to a directory
is_dir = graphene.Boolean()
# True indicates that path points to a favorite
is_favorite = graphene.Boolean()
# Modified at contains timestamp of last modified - NOT creation - in epoch time.
modified_at = graphene.Int()
# Size in bytes encoded as a string.
size = graphene.String()
def _load_file_info(self, dataloader):
"""Private method to retrieve file info for a given key"""
if not self._file_info:
# Load file info from LabBook
if not self.section or not self.key:
raise ValueError(
"Must set `section` and `key` on object creation to resolve file info"
)
# Load labbook instance
lb = dataloader.load(
f"{get_logged_in_username()}&{self.owner}&{self.name}").get()
# Retrieve file info
self._file_info = lb.get_file_info(self.section, self.key)
# Set class properties
self.is_dir = self._file_info['is_dir']
self.modified_at = round(self._file_info['modified_at'])
self.size = f"{self._file_info['size']}"
self.is_favorite = self._file_info['is_favorite']
@classmethod
def get_node(cls, info, id):
"""Method to resolve the object based on it's Node ID"""
# Parse the key
owner, name, section, key = id.split("&")
return LabbookFile(id=f"{owner}&{name}&{section}&{key}",
name=name,
owner=owner,
section=section,
key=key)
def resolve_id(self, info):
"""Resolve the unique Node id for this object"""
if not self.id:
if not self.owner or not self.name or not self.section or not self.key:
raise ValueError(
"Resolving a LabbookFile Node ID requires owner, name, section, and key to be set"
)
self.id = f"{self.owner}&{self.name}&{self.section}&{self.key}"
return self.id
def resolve_is_dir(self, info):
"""Resolve the is_dir field"""
if self.is_dir is None:
self._load_file_info(info.context.labbook_loader)
return self.is_dir
def resolve_modified_at(self, info):
"""Resolve the modified_at field"""
if self.modified_at is None:
self._load_file_info(info.context.labbook_loader)
return self.modified_at
def resolve_size(self, info):
"""Resolve the size field"""
if self.size is None:
self._load_file_info(info.context.labbook_loader)
return self.size
def resolve_is_favorite(self, info):
"""Resolve the is_favorite field"""
if self.is_favorite is None:
self._load_file_info(info.context.labbook_loader)
return self.is_favorite
class Product(CountableDjangoObjectType, MetadataObjectType):
url = graphene.String(description="The storefront URL for the product.",
required=True)
thumbnail = graphene.Field(
Image,
description="The main thumbnail for a product.",
size=graphene.Argument(graphene.Int, description="Size of thumbnail."),
)
availability = graphene.Field(
ProductPricingInfo,
description=
("Informs about product's availability in the storefront, current price and "
"discounts."),
deprecation_reason=
("DEPRECATED: Will be removed in Saleor 2.10, Has been renamed to `pricing`."
),
)
pricing = graphene.Field(
ProductPricingInfo,
description=
("Lists the storefront product's pricing, the current price and discounts, "
"only meant for displaying."),
)
is_available = graphene.Boolean(
description="Whether the product is in stock and visible or not.")
base_price = graphene.Field(
Money, description="The product's default base price.")
price = graphene.Field(
Money,
description="The product's default base price.",
deprecation_reason=(
"DEPRECATED: Will be removed in Saleor 2.10, has been replaced by "
"`basePrice`"),
)
minimal_variant_price = graphene.Field(
Money,
description="The price of the cheapest variant (including discounts).")
tax_type = graphene.Field(
TaxType, description="A type of tax. Assigned by enabled tax gateway")
attributes = graphene.List(
graphene.NonNull(SelectedAttribute),
required=True,
description="List of attributes assigned to this product.",
)
purchase_cost = graphene.Field(MoneyRange)
margin = graphene.Field(Margin)
image_by_id = graphene.Field(
lambda: ProductImage,
id=graphene.Argument(graphene.ID,
description="ID of a product image."),
description="Get a single product image by ID.",
)
variants = gql_optimizer.field(
graphene.List(ProductVariant,
description="List of variants for the product."),
model_field="variants",
)
images = gql_optimizer.field(
graphene.List(lambda: ProductImage,
description="List of images for the product."),
model_field="images",
)
collections = gql_optimizer.field(
graphene.List(lambda: Collection,
description="List of collections for the product."),
model_field="collections",
)
translation = graphene.Field(
ProductTranslation,
language_code=graphene.Argument(
LanguageCodeEnum,
description="A language code to return the translation for.",
required=True,
),
description=(
"Returns translated Product fields for the given language code."),
resolver=resolve_translation,
)
slug = graphene.String(required=True, description="The slug of a product.")
class Meta:
description = "Represents an individual item for sale in the storefront."
interfaces = [relay.Node]
model = models.Product
only_fields = [
"category",
"charge_taxes",
"description",
"description_json",
"id",
"is_published",
"name",
"product_type",
"publication_date",
"seo_description",
"seo_title",
"updated_at",
"weight",
]
@staticmethod
def resolve_tax_type(root: models.Product, info):
tax_data = info.context.extensions.get_tax_code_from_object_meta(root)
return TaxType(tax_code=tax_data.code,
description=tax_data.description)
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related="images")
def resolve_thumbnail(root: models.Product, info, *, size=255):
image = root.get_first_image()
if image:
url = get_product_image_thumbnail(image, size, method="thumbnail")
alt = image.alt
return Image(alt=alt, url=info.context.build_absolute_uri(url))
return None
@staticmethod
def resolve_url(root: models.Product, *_args):
return root.get_absolute_url()
@staticmethod
@gql_optimizer.resolver_hints(
prefetch_related=("variants", "collections"),
only=[
"publication_date", "charge_taxes", "price_amount", "currency",
"meta"
],
)
def resolve_pricing(root: models.Product, info):
context = info.context
availability = get_product_availability(
root,
context.discounts,
context.country,
context.currency,
context.extensions,
)
return ProductPricingInfo(**availability._asdict())
resolve_availability = resolve_pricing
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related=("variants"))
def resolve_is_available(root: models.Product, _info):
return root.is_available
@staticmethod
@permission_required("product.manage_products")
def resolve_base_price(root: models.Product, _info):
return root.price
@staticmethod
@gql_optimizer.resolver_hints(
prefetch_related=("variants", "collections"),
only=[
"publication_date", "charge_taxes", "price_amount", "currency",
"meta"
],
)
def resolve_price(root: models.Product, info):
price_range = root.get_price_range(info.context.discounts)
price = info.context.extensions.apply_taxes_to_product(
root, price_range.start, info.context.country)
return price.net
@staticmethod
@gql_optimizer.resolver_hints(prefetch_related=[
"product_type__attributeproduct__productassignments__values",
"product_type__attributeproduct__attribute",
])
def resolve_attributes(root: models.Product, info):
return resolve_attribute_list(root, user=info.context.user)
@staticmethod
@permission_required("product.manage_products")
def resolve_purchase_cost(root: models.Product, *_args):
purchase_cost, _ = get_product_costs_data(root)
return purchase_cost
@staticmethod
@permission_required("product.manage_products")
def resolve_margin(root: models.Product, *_args):
_, margin = get_product_costs_data(root)
return Margin(margin[0], margin[1])
@staticmethod
def resolve_image_by_id(root: models.Product, info, id):
pk = get_database_id(info, id, ProductImage)
try:
return root.images.get(pk=pk)
except models.ProductImage.DoesNotExist:
raise GraphQLError("Product image not found.")
@staticmethod
@gql_optimizer.resolver_hints(model_field="images")
def resolve_images(root: models.Product, *_args, **_kwargs):
return root.images.all()
@staticmethod
def resolve_variants(root: models.Product, *_args, **_kwargs):
return root.variants.all()
@staticmethod
def resolve_collections(root: models.Product, *_args):
return root.collections.all()
@classmethod
def get_node(cls, info, pk):
if info.context:
qs = cls._meta.model.objects.visible_to_user(info.context.user)
return cls.maybe_optimize(info, qs, pk)
return None
@staticmethod
@permission_required("product.manage_products")
def resolve_private_meta(root, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root, _info):
return resolve_meta(root, _info)
@staticmethod
def resolve_slug(root: models.Product, *_args):
return root.get_slug()
class Product(CountableDjangoObjectType):
url = graphene.String(
description="The storefront URL for the product.",
required=True,
deprecation_reason="This field will be removed after 2020-07-31.",
)
thumbnail = graphene.Field(
Image,
description="The main thumbnail for a product.",
size=graphene.Argument(graphene.Int, description="Size of thumbnail."),
)
pricing = graphene.Field(
ProductPricingInfo,
description=
("Lists the storefront product's pricing, the current price and discounts, "
"only meant for displaying."),
)
is_available = graphene.Boolean(
description="Whether the product is in stock and visible or not.")
base_price = graphene.Field(
Money, description="The product's default base price.")
minimal_variant_price = graphene.Field(
Money,
description="The price of the cheapest variant (including discounts).")
tax_type = graphene.Field(
TaxType, description="A type of tax. Assigned by enabled tax gateway")
attributes = graphene.List(
graphene.NonNull(SelectedAttribute),
required=True,
description="List of attributes assigned to this product.",
)
purchase_cost = graphene.Field(MoneyRange)
margin = graphene.Field(Margin)
image_by_id = graphene.Field(
lambda: ProductImage,
id=graphene.Argument(graphene.ID,
description="ID of a product image."),
description="Get a single product image by ID.",
)
variants = graphene.List(ProductVariant,
description="List of variants for the product.")
images = graphene.List(lambda: ProductImage,
description="List of images for the product.")
collections = graphene.List(
lambda: Collection, description="List of collections for the product.")
translation = TranslationField(ProductTranslation, type_name="product")
class Meta:
description = "Represents an individual item for sale in the storefront."
interfaces = [relay.Node, ObjectWithMetadata]
model = models.Product
only_fields = [
"category",
"charge_taxes",
"description",
"description_json",
"id",
"is_published",
"name",
"slug",
"product_type",
"publication_date",
"seo_description",
"seo_title",
"updated_at",
"weight",
]
@staticmethod
def resolve_category(root: models.Product, info):
category_id = root.category_id
if category_id is None:
return None
return CategoryByIdLoader(info.context).load(category_id)
@staticmethod
def resolve_tax_type(root: models.Product, info):
tax_data = info.context.plugins.get_tax_code_from_object_meta(root)
return TaxType(tax_code=tax_data.code,
description=tax_data.description)
@staticmethod
def resolve_thumbnail(root: models.Product, info, *, size=255):
def return_first_thumbnail(images):
image = images[0] if images else None
if image:
url = get_product_image_thumbnail(image,
size,
method="thumbnail")
alt = image.alt
return Image(alt=alt, url=info.context.build_absolute_uri(url))
return None
return (ImagesByProductIdLoader(info.context).load(
root.id).then(return_first_thumbnail))
@staticmethod
def resolve_url(root: models.Product, *_args):
return ""
@staticmethod
def resolve_pricing(root: models.Product, info):
context = info.context
variants = ProductVariantsByProductIdLoader(context).load(root.id)
collections = CollectionsByProductIdLoader(context).load(root.id)
def calculate_pricing_info(discounts):
def calculate_pricing_with_variants(variants):
def calculate_pricing_with_collections(collections):
availability = get_product_availability(
product=root,
variants=variants,
collections=collections,
discounts=discounts,
country=context.country,
local_currency=context.currency,
plugins=context.plugins,
)
return ProductPricingInfo(**asdict(availability))
return collections.then(calculate_pricing_with_collections)
return variants.then(calculate_pricing_with_variants)
return (DiscountsByDateTimeLoader(context).load(
info.context.request_time).then(calculate_pricing_info))
@staticmethod
def resolve_is_available(root: models.Product, info):
country = info.context.country
in_stock = is_product_in_stock(root, country)
return root.is_visible and in_stock
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_base_price(root: models.Product, _info):
return root.price
@staticmethod
def resolve_price(root: models.Product, info):
context = info.context
def calculate_price(discounts):
price_range = root.get_price_range(discounts)
price = info.context.plugins.apply_taxes_to_product(
root, price_range.start, info.context.country)
return price.net
return (DiscountsByDateTimeLoader(context).load(
info.context.request_time).then(calculate_price))
@staticmethod
def resolve_attributes(root: models.Product, info):
return SelectedAttributesByProductIdLoader(info.context).load(root.id)
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_purchase_cost(root: models.Product, *_args):
purchase_cost, _ = get_product_costs_data(root)
return purchase_cost
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_margin(root: models.Product, *_args):
_, margin = get_product_costs_data(root)
return Margin(margin[0], margin[1])
@staticmethod
def resolve_image_by_id(root: models.Product, info, id):
pk = get_database_id(info, id, ProductImage)
try:
return root.images.get(pk=pk)
except models.ProductImage.DoesNotExist:
raise GraphQLError("Product image not found.")
@staticmethod
def resolve_images(root: models.Product, info, **_kwargs):
return ImagesByProductIdLoader(info.context).load(root.id)
@staticmethod
def resolve_variants(root: models.Product, info, **_kwargs):
return ProductVariantsByProductIdLoader(info.context).load(root.id)
@staticmethod
def resolve_collections(root: models.Product, *_args):
return root.collections.all()
@classmethod
def get_node(cls, info, pk):
if info.context:
qs = cls._meta.model.objects.visible_to_user(info.context.user)
return qs.filter(pk=pk).first()
return None
@staticmethod
@permission_required(ProductPermissions.MANAGE_PRODUCTS)
def resolve_private_meta(root: models.Product, _info):
return resolve_private_meta(root, _info)
@staticmethod
def resolve_meta(root: models.Product, _info):
return resolve_meta(root, _info)
@staticmethod
def __resolve_reference(root, _info, **_kwargs):
return graphene.Node.get_node_from_global_id(_info, root.id)
class URLMeta(graphene.ObjectType):
local = graphene.Boolean()
url = graphene.String(required=True)
class OrderEvent(CountableDjangoObjectType):
date = graphene.types.datetime.DateTime(
description="Date when event happened at in ISO 8601 format."
)
type = OrderEventsEnum(description="Order event type.")
user = graphene.Field(User, description="User who performed the action.")
message = graphene.String(description="Content of the event.")
email = graphene.String(description="Email of the customer.")
email_type = OrderEventsEmailsEnum(
description="Type of an email sent to the customer."
)
amount = graphene.Float(description="Amount of money.")
payment_id = graphene.String(description="The payment ID from the payment gateway.")
payment_gateway = graphene.String(description="The payment gateway of the payment.")
quantity = graphene.Int(description="Number of items.")
composed_id = graphene.String(description="Composed ID of the Fulfillment.")
order_number = graphene.String(description="User-friendly number of an order.")
invoice_number = graphene.String(
description="Number of an invoice related to the order."
)
oversold_items = graphene.List(
graphene.String, description="List of oversold lines names."
)
lines = graphene.List(OrderEventOrderLineObject, description="The concerned lines.")
fulfilled_items = graphene.List(
lambda: FulfillmentLine, description="The lines fulfilled."
)
warehouse = graphene.Field(
Warehouse, description="The warehouse were items were restocked."
)
transaction_reference = graphene.String(
description="The transaction reference of captured payment."
)
shipping_costs_included = graphene.Boolean(
description="Define if shipping costs were included to the refund."
)
related_order = graphene.Field(
lambda: Order, description="The order which is related to this order."
)
discount = graphene.Field(
OrderEventDiscountObject, description="The discount applied to the order."
)
class Meta:
description = "History log of the order."
model = models.OrderEvent
interfaces = [relay.Node]
only_fields = ["id"]
@staticmethod
def resolve_user(root: models.OrderEvent, info):
user = info.context.user
if (
user == root.user
or user.has_perm(AccountPermissions.MANAGE_USERS)
or user.has_perm(AccountPermissions.MANAGE_STAFF)
):
return root.user
raise PermissionDenied()
@staticmethod
def resolve_email(root: models.OrderEvent, _info):
return root.parameters.get("email", None)
@staticmethod
def resolve_email_type(root: models.OrderEvent, _info):
return root.parameters.get("email_type", None)
@staticmethod
def resolve_amount(root: models.OrderEvent, _info):
amount = root.parameters.get("amount", None)
return float(amount) if amount else None
@staticmethod
def resolve_payment_id(root: models.OrderEvent, _info):
return root.parameters.get("payment_id", None)
@staticmethod
def resolve_payment_gateway(root: models.OrderEvent, _info):
return root.parameters.get("payment_gateway", None)
@staticmethod
def resolve_quantity(root: models.OrderEvent, _info):
quantity = root.parameters.get("quantity", None)
return int(quantity) if quantity else None
@staticmethod
def resolve_message(root: models.OrderEvent, _info):
return root.parameters.get("message", None)
@staticmethod
def resolve_composed_id(root: models.OrderEvent, _info):
return root.parameters.get("composed_id", None)
@staticmethod
def resolve_oversold_items(root: models.OrderEvent, _info):
return root.parameters.get("oversold_items", None)
@staticmethod
def resolve_order_number(root: models.OrderEvent, _info):
return root.order_id
@staticmethod
def resolve_invoice_number(root: models.OrderEvent, _info):
return root.parameters.get("invoice_number")
@staticmethod
def resolve_lines(root: models.OrderEvent, info):
raw_lines = root.parameters.get("lines", None)
if not raw_lines:
return None
line_pks = []
for entry in raw_lines:
line_pk = entry.get("line_pk", None)
if line_pk:
line_pks.append(line_pk)
def _resolve_lines(lines):
results = []
lines_dict = {line.pk: line for line in lines if line}
for raw_line in raw_lines:
line_pk = raw_line.get("line_pk")
line_object = lines_dict.get(line_pk)
discount = raw_line.get("discount")
if discount:
discount = get_order_discount_event(discount)
results.append(
OrderEventOrderLineObject(
quantity=raw_line["quantity"],
order_line=line_object,
item_name=raw_line["item"],
discount=discount,
)
)
return results
return (
OrderLineByIdLoader(info.context).load_many(line_pks).then(_resolve_lines)
)
@staticmethod
def resolve_fulfilled_items(root: models.OrderEvent, _info):
lines = root.parameters.get("fulfilled_items", [])
return models.FulfillmentLine.objects.filter(pk__in=lines)
@staticmethod
def resolve_warehouse(root: models.OrderEvent, _info):
warehouse = root.parameters.get("warehouse")
return warehouse_models.Warehouse.objects.filter(pk=warehouse).first()
@staticmethod
def resolve_transaction_reference(root: models.OrderEvent, _info):
return root.parameters.get("transaction_reference")
@staticmethod
def resolve_shipping_costs_included(root: models.OrderEvent, _info):
return root.parameters.get("shipping_costs_included")
@staticmethod
def resolve_related_order(root: models.OrderEvent, info):
order_pk = root.parameters.get("related_order_pk")
if not order_pk:
return None
return OrderByIdLoader(info.context).load(order_pk)
@staticmethod
def resolve_discount(root: models.OrderEvent, info):
discount_obj = root.parameters.get("discount")
if not discount_obj:
return None
return get_order_discount_event(discount_obj)
class NewsGraph(graphene.ObjectType):
title = graphene.String()
body = graphene.String()
publish_date = graphene.types.datetime.Date()
public = graphene.Boolean()
slug = graphene.String()
