class Query(graphene.ObjectType):
personalnotes = graphene.List(PersonalNoteNode)
all_notes = DjangoConnectionField(PersonalNoteNode)
breweries = graphene.List(BreweryNode)
all_breweries = DjangoConnectionField(BreweryNode)
beers = graphene.List(BeerNode)
all_beers = DjangoConnectionField(BeerNode)
def resolve_personalnotes(self, info, title=None, **kwargs):
title = kwargs.get('title')
user = info.context.user
if user.is_anonymous:
return PersonalNote.objects.none()
elif title:
filter = Q(title=title)
return PersonalNotes.objects.filter(filter, user=user)
else:
return PersonalNote.objects.filter(user=user)
def resolve_brewery(self, info):
return Brewery.objects.all()
def resolve_beer(self, info):
return Beer.objects.all()
class EducationQuery(ObjectType):
### Educations ###
educations = DjangoConnectionField(EducationNode)
@login_required
def resolve_educations(self, info, **kwargs):
return self
education = Field(EducationNode, pk=Int())
def resolve_education(self, info, **kwargs):
pk = kwargs.get('pk')
return Education.objects.get(pk=pk)
statuses = DjangoConnectionField(StatusNode)
status = graphene.Field(StatusNode, pk=Int())
def resolve_status(self, info, **kwargs):
pk = kwargs.get('pk')
return Status.objects.get(pk=pk)
categories = DjangoConnectionField(EducationCategoryNode)
tasks = DjangoConnectionField(TaskNode)
task = graphene.Field(TaskNode, pk=Int())
def resolve_task(self, info, **kwargs):
pk = kwargs.get('pk')
return Task.objects.get(pk=pk)
class Query(ObjectType):
genre = Node.Field(GenreNode)
all_genres = DjangoConnectionField(GenreNode)
job = Node.Field(JobNode)
all_jobs = DjangoConnectionField(JobNode)
person = Node.Field(PersonNode)
all_persons = DjangoConnectionField(PersonNode)
movie = Node.Field(MovieNode)
all_movies = DjangoConnectionField(MovieNode)
class Query(ObjectType):
user = Node.Field(UserNode)
all_users = DjangoConnectionField(UserNode)
kit = Node.Field(KitNode)
all_kits = DjangoConnectionField(KitNode)
adapter = Node.Field(AdapterNode)
all_adapters = DjangoConnectionField(AdapterNode)
run = Node.Field(RunNode)
all_runs = DjangoConnectionField(RunNode)
database = Node.Field(DatabaseNode)
all_databases = DjangoConnectionField(DatabaseNode)
class WinterStoragePlaceNode(DjangoObjectType):
leases = DjangoConnectionField(
"leases.schema.WinterStorageLeaseNode",
description="**Requires permissions** to query this field.",
)
width = graphene.Float(description=_("width (m)"), required=True)
length = graphene.Float(description=_("length (m)"), required=True)
is_available = graphene.Boolean(required=True)
class Meta:
model = WinterStoragePlace
fields = (
"id",
"number",
"winter_storage_section",
"is_active",
"created_at",
"modified_at",
)
interfaces = (relay.Node, )
connection_class = CountConnection
@view_permission_required(WinterStorageLease, WinterStorageApplication,
CustomerProfile)
def resolve_leases(self, info, **kwargs):
return self.leases.all()
def resolve_width(self, info, **kwargs):
return self.place_type.width
def resolve_length(self, info, **kwargs):
return self.place_type.length
def __init_subclass_with_meta__(cls,
_meta=None,
model=None,
permissions=None,
object_permissions=None,
object_permissions_any=True,
allow_unauthenticated=False,
prefetch=None,
**kwargs):
if not _meta:
_meta = DjangoObjectTypeOptions(cls)
_meta.permissions = permissions or []
_meta.object_permissions = object_permissions or []
_meta.object_permissions_any = object_permissions_any
_meta.allow_unauthenticated = allow_unauthenticated
# Automatic prefetch optimization
if gql_optimizer is not None:
prefetch = prefetch or {}
for k, v in prefetch.items():
if isinstance(v, types.FunctionType):
v = v()
f = gql_optimizer.field(
DjangoConnectionField(v),
model_field=k,
)
r = lambda s, i, **kw: getattr(s, k).all()
setattr(cls, k, f)
setattr(cls, 'resolve_' + k, r)
super().__init_subclass_with_meta__(_meta=_meta, model=model, **kwargs)
class CheckoutQueries(graphene.ObjectType):
checkout = graphene.Field(Checkout,
description='Single checkout.',
token=graphene.Argument(graphene.UUID))
# FIXME we could optimize the below field
checkouts = DjangoConnectionField(Checkout,
description='List of checkouts.')
checkout_line = graphene.Field(CheckoutLine,
id=graphene.Argument(graphene.ID),
description='Single checkout line.')
checkout_lines = PrefetchingConnectionField(
CheckoutLine, description='List of checkout lines')
def resolve_checkout(self, *_args, token):
return resolve_checkout(token)
@permission_required('order.manage_orders')
def resolve_checkouts(self, *_args, **_kwargs):
resolve_checkouts()
def resolve_checkout_line(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, CheckoutLine)
@permission_required('order.manage_orders')
def resolve_checkout_lines(self, *_args, **_kwargs):
return resolve_checkout_lines()
class WinterStorageSectionNode(graphql_geojson.GeoJSONType):
max_width = graphene.Float()
max_length = graphene.Float()
number_of_places = graphene.Int(required=True)
number_of_free_places = graphene.Int(required=True)
number_of_inactive_places = graphene.Int(required=True)
leases = DjangoConnectionField(
"leases.schema.WinterStorageLeaseNode",
description="**Requires permissions** to query this field.",
)
class Meta:
model = WinterStorageSection
filter_fields = [
"electricity",
"gate",
"water",
"summer_storage_for_docking_equipment",
"summer_storage_for_trailers",
"summer_storage_for_boats",
]
geojson_field = "location"
interfaces = (relay.Node, )
connection_class = CountConnection
@view_permission_required(WinterStorageLease, WinterStorageApplication,
CustomerProfile)
def resolve_leases(self, info, **kwargs):
return self.leases.all()
def connection_resolver(self, resolver, connection, default_manager, filterset_class, filtering_args,
root, args, context, info):
if self.has_perm(context) is not True:
return DjangoConnectionField.connection_resolver(
resolver, connection, [PermissionDenied('Permission Denied'), ], root, args, context, info)
return super(AuthDjangoFilterConnectionField, self).connection_resolver(
resolver, connection, default_manager, filterset_class, filtering_args,
root, args, context, info)
class Query(graphene.ObjectType):
items = graphene.List(ItemInterface, name=graphene.String(required=True))
relay_items = DjangoConnectionField(ItemNode)
relay_items_global_id = DjangoConnectionField(ItemNodeGlobalID)
relay_items_global_uuid = DjangoConnectionField(ItemNodeGlobalUUID)
def resolve_items(root, info, name):
return gql_optimizer.query(Item.objects.filter(name=name), info)
def resolve_relay_items(root, info, **kwargs):
return gql_optimizer.query(Item.objects.all(), info)
def resolve_relay_items_global_id(root, info, **kwargs):
return gql_optimizer.query(Item.objects.all(), info)
def resolve_relay_items_global_uuid(root, info, **kwargs):
return gql_optimizer.QueryOptimizer(info, id_field='uuid').optimize(
Item.objects.all())
class Query(graphene.ObjectType):
artists = graphene.Field(ArtistsNode)
all_artists = DjangoConnectionField(ArtistsNode)
def resolve_artists(self, info):
return Artists.objects.all()
album = graphene.Field(AlbumNode)
all_album = DjangoConnectionField(AlbumNode)
def resolve_album(self, info):
return Album.objects.all()
song = graphene.Field(SongNode)
all_song = DjangoConnectionField(SongNode)
def resolve_song(self, info):
return Song.objects.all()
class FeedQuery(graphene.ObjectType):
feed = graphene.Node.Field(FeedObject)
feeds = DjangoConnectionField(FeedObject,
first=graphene.Int(default_value=5))
def resolve_feeds(self, info, **kwargs):
return Feed.objects.select_related(
'user',
'user__profile').prefetch_related('feed_set').filter(parent=None)
class Query(graphene.ObjectType):
items = graphene.List(ItemInterface, name=graphene.String(required=True))
relay_items = DjangoConnectionField(ItemNode)
def resolve_items(root, info, name):
return gql_optimizer.query(Item.objects.filter(name=name), info)
def resolve_relay_items(root, info, **kwargs):
return gql_optimizer.query(Item.objects.all(), info)
class UserQuery(ObjectType):
### User ###
users = DjangoConnectionField(UserNode)
user = graphene.Field(UserNode, pk=Int())
@login_required
def resolve_user(self, info, **kwargs):
pk = kwargs.get('pk')
return User.objects.get(pk=pk)
logedUser = graphene.Field(UserNode)
@login_required
def resolve_logedUser(self, info, **kwargs):
return info.context.user
class BaseItemType(OptimizedDjangoObjectType):
title = gql_optimizer.field(graphene.String(), only="name",)
father = gql_optimizer.field(
graphene.Field("tests.schema.ItemType"), model_field="parent",
)
relay_all_children = DjangoConnectionField("tests.schema.ItemNode")
class Meta:
model = Item
fields = "__all__"
@gql_optimizer.resolver_hints(model_field="children",)
def resolve_relay_all_children(root, info, **kwargs):
return root.children.all()
class Query(graphene.ObjectType):
"""Uniconvention.com GraphQL endpoint"""
all_events = DjangoConnectionField(EventType)
all_bookings = graphene.List(BookingType)
event = graphene.Field(EventType, id=graphene.Int())
def resolve_all_events(self, info, **kwargs):
return Event.objects.all()
def resolve_all_bookings(self, info, **kwargs):
return Booking.objects.all()
def resolve_event(self, info, **kwargs):
id = kwargs.get("id")
if id is not None:
return Event.objects.get(id=id)
return None
class BerthNode(DjangoObjectType):
leases = DjangoConnectionField(
"leases.schema.BerthLeaseNode",
description="**Requires permissions** to query this field.",
)
is_accessible = graphene.Boolean()
is_available = graphene.Boolean(required=True)
width = graphene.Float(description=_("width (m)"), required=True)
length = graphene.Float(description=_("length (m)"), required=True)
depth = graphene.Float(description=_("depth (m)"))
mooring_type = BerthMooringTypeEnum(required=True)
class Meta:
model = Berth
fields = (
"id",
"number",
"pier",
"comment",
"is_active",
"created_at",
"modified_at",
"is_invoiceable",
)
interfaces = (relay.Node, )
connection_class = CountConnection
@view_permission_required(BerthLease, BerthApplication, CustomerProfile)
def resolve_leases(self, info, **kwargs):
return info.context.leases_for_berth_loader.load(self.id)
def resolve_pier(self, info, **kwargs):
return info.context.pier_loader.load(self.pier_id)
def resolve_width(self, info, **kwargs):
return self.berth_type.width
def resolve_length(self, info, **kwargs):
return self.berth_type.length
def resolve_depth(self, info, **kwargs):
return self.berth_type.depth
def resolve_mooring_type(self, info, **kwargs):
return self.berth_type.mooring_type
class BaseItemType(OptimizedDjangoObjectType):
title = gql_optimizer.field(
graphene.String(),
only='name',
)
father = gql_optimizer.field(
graphene.Field('tests.schema.ItemType'),
model_field='parent',
)
relay_all_children = DjangoConnectionField('tests.schema.ItemNode')
class Meta:
model = Item
@gql_optimizer.resolver_hints(
model_field='children', )
def resolve_relay_all_children(root, info, **kwargs):
return root.children.all()
def connection_resolver(self, resolver, connection, default_manager,
max_limit, enforce_first_or_last, filterset_class,
filtering_args, root, args, context, info):
"""
Resolve the required connection if the user in context has the permission required. If the user
does not have the required permission then returns a *Permission Denied* to the request.
"""
assert self._permissions is not None
if has_perm(self._permissions, context) is not True:
print(DjangoConnectionField)
return DjangoConnectionField.connection_resolver(
resolver, connection, [
PermissionDenied('Permission Denied'),
], max_limit, enforce_first_or_last, root, args, context, info)
return super(AuthDjangoFilterConnectionField,
self).connection_resolver(resolver, connection,
default_manager, max_limit,
enforce_first_or_last,
filterset_class, filtering_args,
root, args, context, info)
class WinterStoragePlaceTypeNode(DjangoObjectType):
places = DjangoConnectionField(
WinterStoragePlaceNode,
description="**Requires permissions** to query this field.",
)
width = graphene.Float(description=_("width (m)"), required=True)
length = graphene.Float(description=_("length (m)"), required=True)
class Meta:
model = WinterStoragePlaceType
fields = (
"id",
"created_at",
"modified_at",
)
interfaces = (relay.Node, )
connection_class = CountConnection
def resolve_places(self, info, **kwargs):
return self.places.all()
class PierNode(graphql_geojson.GeoJSONType):
number_of_free_places = graphene.Int(required=True)
number_of_inactive_places = graphene.Int(required=True)
number_of_places = graphene.Int(required=True)
max_width = graphene.Float()
max_length = graphene.Float()
max_depth = graphene.Float()
price_tier = graphene.Field("payments.schema.PriceTierEnum")
suitable_boat_types = graphene.NonNull(
graphene.List(graphene.NonNull("resources.schema.BoatTypeType")))
berths = DjangoConnectionField("resources.schema.BerthNode",
is_available=graphene.Boolean(),
required=True)
class Meta:
model = Pier
filter_fields = [
"mooring",
"electricity",
"water",
"waste_collection",
"gate",
"lighting",
"suitable_boat_types",
"harbor",
]
geojson_field = "location"
interfaces = (relay.Node, )
connection_class = CountConnection
def resolve_berths(self, info, **kwargs):
filters = Q()
if "is_available" in kwargs:
filters &= Q(is_available=kwargs.get("is_available"))
return info.context.berth_loader.load_many(
keys=self.berths.filter(filters).values_list("id", flat=True))
def resolve_suitable_boat_types(self, info, **kwargs):
return info.context.suitable_boat_type_loader.load_many(
keys=self.suitable_boat_types.values_list("id", flat=True))
class DealNode(DjangoObjectType):
name = graphene.String()
deal_value = graphene.Float()
# We can't do a filter field because buyers_without_transaction returns a list
buyers_without_transaction = DjangoConnectionField(BuyerNode)
waitlist_buyers = DjangoFilterConnectionField(BuyerNode)
class Meta:
model = Deal
interfaces = (relay.Node, )
auth = {
# In Deal
'id': [public],
'share_price': [logged_in],
'name': [DealPermissions.check_seller_in_deal],
'deal_value': [DealPermissions.check_seller_in_deal],
'buyers_without_transaction': [public],
'waitlist_buyers': [public],
}
@classmethod
@graphene_auth([is_staff, DealPermissions.check_seller_in_deal])
def get_node(cls, info, id):
return Deal.objects.get(id=id)
@staticmethod
def resolve_share_price(obj, info, **kwargs):
share_price = obj.share_price
return share_price
@staticmethod
def resolve_buyers_without_transaction(obj, info, **kwargs):
return obj.buyers_without_transaction()
@staticmethod
def resolve_waitlist_buyers(obj, info, **kwargs):
return obj.waitlist_buyers().filter()
class User(CountableDjangoObjectType):
groups = DjangoConnectionField(Group)
permissions = graphene.List(PermissionDisplay)
class Meta:
exclude_fields = [
'date_joined', 'password', 'is_superuser', 'ordernote_set',
'orderhistoryentry_set', 'last_login'
]
description = 'Represents user data.'
interfaces = [relay.Node]
model = get_user_model()
filter_fields = ['is_staff']
def resolve_permissions(self, info, **kwargs):
if self.is_superuser:
permissions = auth_models.Permission.objects.all()
else:
permissions = (
self.user_permissions.all()
| auth_models.Permission.objects.filter(group__user=self))
permissions = permissions.select_related('content_type')
return format_permissions_for_display(permissions)
class BuyerNode(DjangoObjectType):
one_deal = graphene.Field('kemcho.equityinvest.schema.DealNode')
many_deals = DjangoConnectionField('kemcho.equityinvest.schema.DealNode')
class Meta:
model = Buyer
interfaces = (relay.Node, )
filter_fields = {
'investment_entity': ['exact', 'icontains', 'istartswith'],
}
@staticmethod
def resolve_one_deal(obj, info, **kwargs):
return Deal.objects.first()
@staticmethod
def resolve_many_deals(obj, info, **kwargs):
return Deal.objects.filter(share_price=26)
@classmethod
@graphene_auth(['staff', 'self'])
def get_node(cls, info, id):
return Buyer.objects.get(id=id)
class Query(graphene.ObjectType):
places = DjangoConnectionField(nodes.PlaceNode)
class Query(ProductQueries):
address_validator = graphene.Field(
AddressValidationData,
input=graphene.Argument(AddressValidationInput, required=True))
checkout = graphene.Field(
Checkout, description='Single checkout.',
token=graphene.Argument(graphene.UUID))
# FIXME we could optimize the below field
checkouts = DjangoConnectionField(
Checkout, description='List of checkouts.')
checkout_lines = PrefetchingConnectionField(
CheckoutLine, description='List of checkout lines')
checkout_line = graphene.Field(
CheckoutLine, id=graphene.Argument(graphene.ID),
description='Single checkout line.')
menu = graphene.Field(
Menu, id=graphene.Argument(graphene.ID),
name=graphene.Argument(graphene.String, description="Menu name."),
description='Lookup a menu by ID or name.')
menus = PrefetchingConnectionField(
Menu, query=graphene.String(description=DESCRIPTIONS['menu']),
description="List of the shop\'s menus.")
menu_item = graphene.Field(
MenuItem, id=graphene.Argument(graphene.ID, required=True),
description='Lookup a menu item by ID.')
menu_items = PrefetchingConnectionField(
MenuItem, query=graphene.String(description=DESCRIPTIONS['menu_item']),
description='List of the shop\'s menu items.')
order = graphene.Field(
Order, description='Lookup an order by ID.',
id=graphene.Argument(graphene.ID, required=True))
orders_total = graphene.Field(
TaxedMoney, description='Total sales.',
period=graphene.Argument(
ReportingPeriod,
description='Get total sales for selected span of time.'))
orders = PrefetchingConnectionField(
Order,
query=graphene.String(description=DESCRIPTIONS['order']),
created=graphene.Argument(
ReportingPeriod,
description='Filter orders from a selected timespan.'),
status=graphene.Argument(
OrderStatusFilter, description='Filter order by status'),
description='List of the shop\'s orders.')
homepage_events = PrefetchingConnectionField(
OrderEvent, description=dedent('''List of activity events to display on
homepage (at the moment it only contains order-events).'''))
page = graphene.Field(
Page, id=graphene.Argument(graphene.ID), slug=graphene.String(),
description='Lookup a page by ID or by slug.')
pages = PrefetchingConnectionField(
Page, query=graphene.String(
description=DESCRIPTIONS['page']),
description='List of the shop\'s pages.')
payment = graphene.Field(Payment, id=graphene.Argument(graphene.ID))
payment_client_token = graphene.Field(
graphene.String, args={'gateway': PaymentGatewayEnum()})
payments = PrefetchingConnectionField(
Payment, description='List of payments')
sale = graphene.Field(
Sale, id=graphene.Argument(graphene.ID, required=True),
description='Lookup a sale by ID.')
sales = PrefetchingConnectionField(
Sale, query=graphene.String(description=DESCRIPTIONS['sale']),
description="List of the shop\'s sales.")
shop = graphene.Field(Shop, description='Represents a shop resources.')
voucher = graphene.Field(
Voucher, id=graphene.Argument(graphene.ID, required=True),
description='Lookup a voucher by ID.')
vouchers = PrefetchingConnectionField(
Voucher, query=graphene.String(description=DESCRIPTIONS['product']),
description="List of the shop\'s vouchers.")
shipping_zone = graphene.Field(
ShippingZone, id=graphene.Argument(graphene.ID, required=True),
description='Lookup a shipping zone by ID.')
shipping_zones = PrefetchingConnectionField(
ShippingZone, description='List of the shop\'s shipping zones.')
user = graphene.Field(
User, id=graphene.Argument(graphene.ID, required=True),
description='Lookup an user by ID.')
customers = PrefetchingConnectionField(
User, description='List of the shop\'s users.',
query=graphene.String(
description=DESCRIPTIONS['user']))
staff_users = PrefetchingConnectionField(
User, description='List of the shop\'s staff users.',
query=graphene.String(description=DESCRIPTIONS['user']))
node = graphene.Node.Field()
def resolve_checkout(self, info, token):
return resolve_checkout(info, token)
def resolve_checkout_line(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, CheckoutLine)
@permission_required('order.manage_orders')
def resolve_checkout_lines(self, info, query=None, **kwargs):
return resolve_checkout_lines(info, query)
@permission_required('order.manage_orders')
def resolve_checkouts(self, info, query=None, **kwargs):
resolve_checkouts(info, query)
@permission_required('account.manage_users')
def resolve_user(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, User)
@permission_required('account.manage_users')
def resolve_customers(self, info, query=None, **kwargs):
return resolve_customers(info, query=query)
@permission_required('account.manage_staff')
def resolve_staff_users(self, info, query=None, **kwargs):
return resolve_staff_users(info, query=query)
def resolve_menu(self, info, id=None, name=None):
return resolve_menu(info, id, name)
def resolve_menus(self, info, query=None, **kwargs):
return resolve_menus(info, query)
def resolve_menu_item(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, MenuItem)
def resolve_menu_items(self, info, query=None, **kwargs):
return resolve_menu_items(info, query)
def resolve_page(self, info, id=None, slug=None):
return resolve_page(info, id, slug)
def resolve_pages(self, info, query=None, **kwargs):
return resolve_pages(info, query=query)
@login_required
def resolve_order(self, info, id):
return resolve_order(info, id)
@permission_required('order.manage_orders')
def resolve_orders_total(self, info, period, **kwargs):
return resolve_orders_total(info, period)
@login_required
def resolve_orders(self, info, query=None, **kwargs):
return resolve_orders(info, query)
def resolve_payment(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Payment)
def resolve_payment_client_token(self, info, gateway=None):
return resolve_payment_client_token(gateway)
@permission_required('order.manage_orders')
def resolve_payments(self, info, query=None, **kwargs):
return resolve_payments(info, query)
@login_required
def resolve_orders(
self, info, created=None, status=None, query=None, **kwargs):
return resolve_orders(info, created, status, query)
@permission_required('order.manage_orders')
def resolve_homepage_events(self, info, **kwargs):
return resolve_homepage_events(info)
def resolve_shop(self, info):
return Shop()
@permission_required('discount.manage_discounts')
def resolve_sale(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Sale)
@permission_required('discount.manage_discounts')
def resolve_sales(self, info, query=None, **kwargs):
return resolve_sales(info, query)
@permission_required('discount.manage_discounts')
def resolve_voucher(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Voucher)
@permission_required('discount.manage_discounts')
def resolve_vouchers(self, info, query=None, **kwargs):
return resolve_vouchers(info, query)
@permission_required('shipping.manage_shipping')
def resolve_shipping_zone(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, ShippingZone)
@permission_required('shipping.manage_shipping')
def resolve_shipping_zones(self, info, **kwargs):
return resolve_shipping_zones(info)
def resolve_address_validator(self, info, input):
return resolve_address_validator(info, input)
class Query(ObjectType):
category = Node.Field(CategoryNode)
all_categories = DjangoConnectionField(CategoryNode)
ingredient = Node.Field(IngredientNode)
all_ingredients = DjangoConnectionField(IngredientNode)
class Query(ObjectType):
reporte = Node.Field(ReporteNode)
all_reportes = DjangoConnectionField(ReporteNode)
class Query(ObjectType):
dsApp = Node.Field(DSAppNode)
allDSApps = DjangoConnectionField(DSAppNode)
class Query(ObjectType):
program = Node.Field(ProgramNode)
all_programs = DjangoConnectionField(ProgramNode)
wod = Node.Field(WODNode)
all_wods = DjangoConnectionField(WODNode)
