class Input:
headline = graphene.String()
reporter_id = graphene.ID()
class RollMarkingActivitiesInput(graphene.InputObjectType):
userId = graphene.ID()
class MovieInput(graphene.InputObjectType):
id = graphene.ID()
title = graphene.String()
actors = graphene.List(ActorInput)
year = graphene.Int()
class Arguments:
id = graphene.ID(description="ID of the order line to update.", required=True)
input = OrderLineInput(
required=True, description="Fields required to update an order line."
)
class Arguments:
pk = graphene.ID(required=True)
content = graphene.String(required=True)
class Arguments:
id = graphene.ID(required=True, description="ID of the order to void.")
class Arguments:
id = graphene.ID(description="ID of an order to confirm.", required=True)
class Arguments:
contest_id = graphene.ID(required=True)
student_id = graphene.ID(required=True)
class UserCreationInput(graphene.InputObjectType):
name = graphene.String()
email = graphene.String(required=True)
password = graphene.String(required=True)
eventID = graphene.ID()
UTMSource = graphene.String()
class Arguments:
student_id = graphene.ID(required=True)
contest_id = graphene.ID(required=True)
team_id = graphene.ID(required=False)
attended = graphene.Boolean(required=True)
class Arguments:
scores = graphene.List(ScoreInput)
contest_id = graphene.ID(required=True)
student_id = graphene.ID(required=True)
class Input:
id = graphene.ID(required=True)
class Input:
id = graphene.ID(required=True)
is_active = graphene.Boolean(required=True)
class Input:
id = graphene.ID(required=False)
password_current = graphene.String(required=False)
password_new = graphene.String(required=True)
class OrderUpdateShippingInput(graphene.InputObjectType):
shipping_method = graphene.ID(
description="ID of the selected shipping method.", name="shippingMethod"
)
class Arguments:
payment_id = graphene.ID(required=True, description='Payment ID')
amount = Decimal(description='Transaction amount')
class Arguments:
id = graphene.ID(required=True, description="ID of the order to mark paid.")
transaction_reference = graphene.String(
required=False, description="The external transaction reference."
)
class Arguments:
payment_id = graphene.ID(required=True, description='Payment ID')
class Arguments:
id = graphene.ID(required=True, description="ID of the order to refund.")
amount = PositiveDecimal(
required=True, description="Amount of money to refund."
)
class Arguments:
checkout_id = graphene.ID(description='Checkout ID.', required=True)
input = PaymentInput(
description='Data required to create a new payment.',
required=True)
class Arguments:
id = graphene.ID(description="ID of the order line to delete.", required=True)
class Checkout(ModelObjectType):
id = graphene.ID(required=True)
created = graphene.DateTime(required=True)
last_change = graphene.DateTime(required=True)
user = graphene.Field("saleor.graphql.account.types.User")
channel = graphene.Field(Channel, required=True)
billing_address = graphene.Field("saleor.graphql.account.types.Address")
shipping_address = graphene.Field("saleor.graphql.account.types.Address")
note = graphene.String(required=True)
discount = graphene.Field(Money)
discount_name = graphene.String()
translated_discount_name = graphene.String()
voucher_code = graphene.String()
available_shipping_methods = graphene.List(
ShippingMethod,
required=True,
description="Shipping methods that can be used with this checkout.",
deprecation_reason=(f"{DEPRECATED_IN_3X_FIELD} Use `shippingMethods` instead."),
)
shipping_methods = graphene.List(
ShippingMethod,
required=True,
description="Shipping methods that can be used with this checkout.",
)
available_collection_points = graphene.List(
graphene.NonNull(Warehouse),
required=True,
description=(
f"{ADDED_IN_31} Collection points that can be used for this order. "
f"{PREVIEW_FEATURE}"
),
)
available_payment_gateways = graphene.List(
graphene.NonNull(PaymentGateway),
description="List of available payment gateways.",
required=True,
)
email = graphene.String(description="Email of a customer.", required=False)
gift_cards = graphene.List(
GiftCard, description="List of gift cards associated with this checkout."
)
is_shipping_required = graphene.Boolean(
description="Returns True, if checkout requires shipping.", required=True
)
quantity = graphene.Int(required=True, description="The number of items purchased.")
stock_reservation_expires = graphene.DateTime(
description=(
f"{ADDED_IN_31} Date when oldest stock reservation for this checkout "
" expires or null if no stock is reserved."
),
)
lines = graphene.List(
CheckoutLine,
description=(
"A list of checkout lines, each containing information about "
"an item in the checkout."
),
)
shipping_price = graphene.Field(
TaxedMoney,
description="The price of the shipping, with all the taxes included.",
)
shipping_method = graphene.Field(
ShippingMethod,
description="The shipping method related with checkout.",
deprecation_reason=(f"{DEPRECATED_IN_3X_FIELD} Use `deliveryMethod` instead."),
)
delivery_method = graphene.Field(
DeliveryMethod,
description=(
f"{ADDED_IN_31} The delivery method selected for this checkout. "
f"{PREVIEW_FEATURE}"
),
)
subtotal_price = graphene.Field(
TaxedMoney,
description="The price of the checkout before shipping, with taxes included.",
)
token = graphene.Field(UUID, description="The checkout's token.", required=True)
total_price = graphene.Field(
TaxedMoney,
description=(
"The sum of the the checkout line prices, with all the taxes,"
"shipping costs, and discounts included."
),
)
language_code = graphene.Field(
LanguageCodeEnum, required=True, description="Checkout language code."
)
class Meta:
description = "Checkout object."
model = models.Checkout
interfaces = [graphene.relay.Node, ObjectWithMetadata]
@staticmethod
def resolve_id(root: models.Checkout, _):
return graphene.Node.to_global_id("Checkout", root.pk)
@staticmethod
def resolve_shipping_address(root: models.Checkout, info):
if not root.shipping_address_id:
return
return AddressByIdLoader(info.context).load(root.shipping_address_id)
@staticmethod
def resolve_billing_address(root: models.Checkout, info):
if not root.billing_address_id:
return
return AddressByIdLoader(info.context).load(root.billing_address_id)
@staticmethod
def resolve_user(root: models.Checkout, info):
requestor = get_user_or_app_from_context(info.context)
check_requestor_access(requestor, root.user, AccountPermissions.MANAGE_USERS)
return root.user
@staticmethod
def resolve_email(root: models.Checkout, _info):
return root.get_customer_email()
@classmethod
def resolve_shipping_method(cls, root: models.Checkout, info):
def with_checkout_info(checkout_info):
delivery_method = checkout_info.delivery_method_info.delivery_method
if not delivery_method or not isinstance(
delivery_method, ShippingMethodData
):
return
return delivery_method
return (
CheckoutInfoByCheckoutTokenLoader(info.context)
.load(root.token)
.then(with_checkout_info)
)
@classmethod
@traced_resolver
def resolve_shipping_methods(cls, root: models.Checkout, info):
return (
CheckoutInfoByCheckoutTokenLoader(info.context)
.load(root.token)
.then(lambda checkout_info: checkout_info.all_shipping_methods)
)
@staticmethod
def resolve_delivery_method(root: models.Checkout, info):
return (
CheckoutInfoByCheckoutTokenLoader(info.context)
.load(root.token)
.then(
lambda checkout_info: checkout_info.delivery_method_info.delivery_method
)
)
@staticmethod
def resolve_quantity(root: models.Checkout, info):
checkout_info = CheckoutLinesInfoByCheckoutTokenLoader(info.context).load(
root.token
)
def calculate_quantity(lines):
return sum([line_info.line.quantity for line_info in lines])
return checkout_info.then(calculate_quantity)
@staticmethod
@traced_resolver
# TODO: We should optimize it in/after PR#5819
def resolve_total_price(root: models.Checkout, info):
def calculate_total_price(data):
address, lines, checkout_info, discounts = data
taxed_total = (
calculations.checkout_total(
manager=info.context.plugins,
checkout_info=checkout_info,
lines=lines,
address=address,
discounts=discounts,
)
- root.get_total_gift_cards_balance()
)
return max(taxed_total, zero_taxed_money(root.currency))
address_id = root.shipping_address_id or root.billing_address_id
address = (
AddressByIdLoader(info.context).load(address_id) if address_id else None
)
lines = CheckoutLinesInfoByCheckoutTokenLoader(info.context).load(root.token)
checkout_info = CheckoutInfoByCheckoutTokenLoader(info.context).load(root.token)
discounts = DiscountsByDateTimeLoader(info.context).load(
info.context.request_time
)
return Promise.all([address, lines, checkout_info, discounts]).then(
calculate_total_price
)
@staticmethod
@traced_resolver
# TODO: We should optimize it in/after PR#5819
def resolve_subtotal_price(root: models.Checkout, info):
def calculate_subtotal_price(data):
address, lines, checkout_info, discounts = data
return calculations.checkout_subtotal(
manager=info.context.plugins,
checkout_info=checkout_info,
lines=lines,
address=address,
discounts=discounts,
)
address_id = root.shipping_address_id or root.billing_address_id
address = (
AddressByIdLoader(info.context).load(address_id) if address_id else None
)
lines = CheckoutLinesInfoByCheckoutTokenLoader(info.context).load(root.token)
checkout_info = CheckoutInfoByCheckoutTokenLoader(info.context).load(root.token)
discounts = DiscountsByDateTimeLoader(info.context).load(
info.context.request_time
)
return Promise.all([address, lines, checkout_info, discounts]).then(
calculate_subtotal_price
)
@staticmethod
@traced_resolver
# TODO: We should optimize it in/after PR#5819
def resolve_shipping_price(root: models.Checkout, info):
def calculate_shipping_price(data):
address, lines, checkout_info, discounts = data
return calculations.checkout_shipping_price(
manager=info.context.plugins,
checkout_info=checkout_info,
lines=lines,
address=address,
discounts=discounts,
)
address = (
AddressByIdLoader(info.context).load(root.shipping_address_id)
if root.shipping_address_id
else None
)
lines = CheckoutLinesInfoByCheckoutTokenLoader(info.context).load(root.token)
checkout_info = CheckoutInfoByCheckoutTokenLoader(info.context).load(root.token)
discounts = DiscountsByDateTimeLoader(info.context).load(
info.context.request_time
)
return Promise.all([address, lines, checkout_info, discounts]).then(
calculate_shipping_price
)
@staticmethod
def resolve_lines(root: models.Checkout, info):
return CheckoutLinesByCheckoutTokenLoader(info.context).load(root.token)
@staticmethod
@traced_resolver
def resolve_available_shipping_methods(root: models.Checkout, info):
return (
CheckoutInfoByCheckoutTokenLoader(info.context)
.load(root.token)
.then(lambda checkout_info: checkout_info.valid_shipping_methods)
)
@staticmethod
@traced_resolver
def resolve_available_collection_points(root: models.Checkout, info):
def get_available_collection_points(data):
address, lines, channel = data
if address:
country_code = address.country.code
else:
country_code = channel.default_country.code
return get_valid_collection_points_for_checkout(
lines, country_code=country_code
)
lines = CheckoutLinesInfoByCheckoutTokenLoader(info.context).load(root.token)
channel = ChannelByIdLoader(info.context).load(root.channel_id)
address = (
AddressByIdLoader(info.context).load(root.shipping_address_id)
if root.shipping_address_id
else None
)
return Promise.all([address, lines, channel]).then(
get_available_collection_points
)
@staticmethod
def resolve_available_payment_gateways(root: models.Checkout, info):
return info.context.plugins.list_payment_gateways(
currency=root.currency, checkout=root, channel_slug=root.channel.slug
)
@staticmethod
def resolve_gift_cards(root: models.Checkout, _info):
return root.gift_cards.all()
@staticmethod
def resolve_is_shipping_required(root: models.Checkout, info):
def is_shipping_required(lines):
product_ids = [line_info.product.id for line_info in lines]
def with_product_types(product_types):
return any([pt.is_shipping_required for pt in product_types])
return (
ProductTypeByProductIdLoader(info.context)
.load_many(product_ids)
.then(with_product_types)
)
return (
CheckoutLinesInfoByCheckoutTokenLoader(info.context)
.load(root.token)
.then(is_shipping_required)
)
@staticmethod
def resolve_language_code(root, _info, **_kwargs):
return LanguageCodeEnum[str_to_enum(root.language_code)]
@staticmethod
@traced_resolver
def resolve_stock_reservation_expires(root: models.Checkout, info):
if not is_reservation_enabled(info.context.site.settings):
return None
def get_oldest_stock_reservation_expiration_date(reservations):
if not reservations:
return None
return min(reservation.reserved_until for reservation in reservations)
return (
StocksReservationsByCheckoutTokenLoader(info.context)
.load(root.token)
.then(get_oldest_stock_reservation_expiration_date)
)
class Arguments:
pk = graphene.ID(required=True)
class ThemeSelectionInput(graphene.InputObjectType):
theme_id = graphene.ID(required=True)
selected = graphene.Boolean(required=True)
class Arguments:
product_data = graphene.Argument(ProductUpdateInput, required=True)
product_id = graphene.ID()
class PublishableChannelListingInput(graphene.InputObjectType):
channel_id = graphene.ID(required=True, description="ID of a channel.")
is_published = graphene.Boolean(
description="Determines if object is visible to customers.")
publication_date = graphene.types.datetime.Date(
description="Publication date. ISO 8601 standard.")
class ActorInput(graphene.InputObjectType):
id = graphene.ID()
name = graphene.String()
class Query(graphene.ObjectType):
"""Queries related to the revisioner models.
"""
run = relay.Node.Field(schema.RunType)
run_history = fields.AuthConnectionField(
type=schema.RunType,
datastore_id=graphene.ID(required=True),
)
run_revisions = fields.AuthConnectionField(
type=schema.RevisionType,
run_id=graphene.ID(required=True),
filterset_class=filters.RevisionFilterSet,
)
table_revisions = fields.AuthConnectionField(
type=schema.RevisionType,
table_id=graphene.ID(required=True),
)
@definition_permissions.can_view_datastore_objects(lambda instance: instance.datastore)
def resolve_run(self, info, id, *args, **kwargs):
"""Retrieve a specific run by the global ID.
"""
_type, pk = shortcuts.from_global_id(id)
get_kwargs = {
'workspace': info.context.workspace,
'pk': pk,
}
return shortcuts.get_object_or_404(models.Run, **get_kwargs)
def resolve_run_history(self, info, datastore_id, *args, **kwargs):
"""Retrieve the last 30 active runs.
"""
get_kwargs = {
'workspace': info.context.workspace,
'pk': shortcuts.from_global_id(datastore_id, True),
}
datastore = shortcuts.get_object_or_404(models.Datastore, **get_kwargs)
if not definition_permissions.request_can_view_datastore(info, datastore):
raise errors.PermissionDenied()
return datastore.run_history.filter(started_at__isnull=False).order_by('-started_at').prefetch_related('errors')
def resolve_run_revisions(self, info, run_id, *args, **kwargs):
"""Retrieve revisions for the provided object.
"""
_type, pk = shortcuts.from_global_id(run_id)
get_kwargs = {
'workspace': info.context.workspace,
'pk': pk,
}
resource = shortcuts.get_object_or_404(models.Run, **get_kwargs)
revisions = resource.revisions\
.filter(applied_on__isnull=False)\
.exclude(metadata__field__isnull=False, metadata__field='object_id')\
.order_by('created_at')
return revisions
def resolve_table_revisions(self, info, table_id, *args, **kwargs):
"""Retrieve revisions for the provided object.
"""
_type, pk = shortcuts.from_global_id(table_id)
get_kwargs = {
'workspace': info.context.workspace,
'pk': pk,
}
resource = shortcuts.get_object_or_404(Table, **get_kwargs)
revisions = models.Revision.objects\
.for_model_instance(resource)\
.filter(applied_on__isnull=False)\
.exclude(metadata__field__isnull=False, metadata__field='object_id')\
.order_by('created_at', 'resource_type_id')
return revisions
class Arguments:
id = graphene.ID(required=True,
description='ID of an order to update.')
input = OrderUpdateInput(
required=True, description='Fields required to update an order.')
class GiftCardEvent(CountableDjangoObjectType):
date = graphene.types.datetime.DateTime(
description="Date when event happened at in ISO 8601 format.")
type = GiftCardEventsEnum(description="Gift card event type.")
user = graphene.Field(
"saleor.graphql.account.types.User",
description="User who performed the action.",
)
app = graphene.Field(App, description="App that performed the action.")
message = graphene.String(description="Content of the event.")
email = graphene.String(description="Email of the customer.")
order_id = graphene.ID(
description="The order ID where gift card was used or bought.")
order_number = graphene.String(description=(
"User-friendly number of an order where gift card was used or bought."
))
tag = graphene.String(description="The gift card tag.")
old_tag = graphene.String(description="Old gift card tag.")
balance = graphene.Field(GiftCardEventBalance,
description="The gift card balance.")
expiry_date = graphene.types.datetime.Date(
description="The gift card expiry date.")
old_expiry_date = graphene.types.datetime.Date(
description="Previous gift card expiry date.")
class Meta:
description = f"{ADDED_IN_31} History log of the gift card."
model = models.GiftCardEvent
interfaces = [graphene.relay.Node]
only_fields = ["id"]
@staticmethod
def resolve_user(root: models.GiftCardEvent, info):
def _resolve_user(event_user):
requester = get_user_or_app_from_context(info.context)
if (requester == event_user
or requester.has_perm(AccountPermissions.MANAGE_USERS)
or requester.has_perm(AccountPermissions.MANAGE_STAFF)):
return event_user
return PermissionDenied()
if root.user_id is None:
return _resolve_user(None)
return UserByUserIdLoader(info.context).load(
root.user_id).then(_resolve_user)
@staticmethod
def resolve_app(root: models.GiftCardEvent, info):
def _resolve_app(app):
requester = get_user_or_app_from_context(info.context)
if requester == app or requester.has_perm(
AppPermission.MANAGE_APPS):
return app
return PermissionDenied()
if root.app_id is None:
return _resolve_app(None)
return AppByIdLoader(info.context).load(root.app_id).then(_resolve_app)
@staticmethod
def resolve_message(root: models.GiftCardEvent, _info):
return root.parameters.get("message")
@staticmethod
def resolve_email(root: models.GiftCardEvent, _info):
return root.parameters.get("email")
@staticmethod
def resolve_order_id(root: models.GiftCardEvent, info):
order_id = root.parameters.get("order_id")
return graphene.Node.to_global_id("Order",
order_id) if order_id else None
@staticmethod
def resolve_order_number(root: models.GiftCardEvent, info):
order_id = root.parameters.get("order_id")
return str(order_id) if order_id else None
@staticmethod
def resolve_tag(root: models.GiftCardEvent, _info):
return root.parameters.get("tag")
@staticmethod
def resolve_old_tag(root: models.GiftCardEvent, _info):
return root.parameters.get("old_tag")
@staticmethod
@traced_resolver
def resolve_balance(root: models.GiftCardEvent, _info):
balance = root.parameters.get("balance")
if balance is None:
return None
currency = balance["currency"]
balance_data = {}
for field in [
"initial_balance",
"old_initial_balance",
"current_balance",
"old_current_balance",
]:
amount = balance.get(field)
if amount is not None:
balance_data[field] = prices.Money(Decimal(amount), currency)
return GiftCardEventBalance(**balance_data)
@staticmethod
def resolve_expiry_date(root: models.GiftCardEvent, _info):
expiry_date = root.parameters.get("expiry_date")
return (datetime.datetime.strptime(expiry_date, "%Y-%m-%d")
if expiry_date else None)
@staticmethod
def resolve_old_expiry_date(root: models.GiftCardEvent, _info):
expiry_date = root.parameters.get("old_expiry_date")
return (datetime.datetime.strptime(expiry_date, "%Y-%m-%d")
if expiry_date else None)
