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)