class Query(object): all_Doner = DjangoFilterConnectionField(DonerType) all_Donation = DjangoFilterConnectionField(DonationType) def resolve_all_Doner(self, info, **kwargs): return Doner.objects.all() def resolve_all_Donation(self, info, **kwargs): return Donation.objects.all()
class Query(AbstractType): meetup = Node.Field(MeetupNode) all_meetups = DjangoFilterConnectionField(MeetupNode) attendee = Node.Field(AttendeeNode) all_attendees = DjangoFilterConnectionField(AttendeeNode) my_meetups = DjangoFilterConnectionField(MeetupNode) def resolve_my_meetups(self, args, context, info): if not context.user.is_authenticated(): return MeetupModel.objects.none() else: return MeetupModel.objects.filter(attendee__user=context.user, **args)
class Query(AbstractType): event = Node.Field(EventNode) all_events = DjangoFilterConnectionField(EventNode) event_attendee = Node.Field(EventAttendeeNode) all_event_attendees = DjangoFilterConnectionField(EventAttendeeNode) my_events = DjangoFilterConnectionField(EventNode) event_image = Node.Field(EventImageNode) all_event_images = DjangoFilterConnectionField(EventImageNode) def resolve_my_events(self, args, context, info): if not context.user.is_authenticated(): return EventModel.objects.none() else: return EventModel.objects.filter(attendee__user=context.user, **args)
class Query(graphene.ObjectType): ##Query all the records from the DB all_nims = graphene.List(NimsTmusType) def resolve_all_nims(self, info, **kwargs): return NimsTmus.objects.all() ##Connect to Relay Node to apply filter filds and pagination all_nimsrecs = DjangoFilterConnectionField(NimsTmusType) all_celloms = graphene.List(CellOMType) def resolve_all_celloms(self, info, **kwargs): return CellOM.objects.select_related('enb').all() all_enboms = graphene.List(EnbOMType) def resolve_all_enboms(self, info, **kwargs): return EnbOM.objects.all() cellom = graphene.Field(CellOMType, cellid=graphene.Int()) def resolve_cellom(self, info, **kwargs): cellid = kwargs.get('cellid') if cellid is not None: return CellOM.objects.get(cellid=cellid) enbom = graphene.Field(EnbOMType, enb=graphene.Int()) def resolve_enbom(self, info, **kwargs): enb = kwargs.get('enb') if enb is not None: return EnbOM.objects.get(enb=enb)
class Query(graphene.ObjectType): film = relay.Node.Field(FilmType) filmAll = DjangoFilterConnectionField(FilmType) people = relay.Node.Field(PeopleType) planet = relay.Node.Field(PlanetType) species = relay.Node.Field(SpeciesType) transport = relay.Node.Field(TransportType) starship = relay.Node.Field(StarshipType) vehicle = relay.Node.Field(VehicleType) def resolve_film(self, info): return FilmModel.objects.all() def resolve_people(self, info): return PeopleModel.objects.all() def resolve_planet(self, info): return PlanetModel.objects.all() def resolve_species(self, info): return SpeciesModel.objects.all() def resolve_transport(self, info): return TransportModel.objects.all() def resolve_starship(self, info): return StarshipModel.objects.all() def resolve_vehicle(self, info): return VehicleModel.objects.all()
class Query(AbstractType): group = Node.Field(GroupNode) group_image = Node.Field(GroupImageNode) all_group_images = DjangoFilterConnectionField(GroupImageNode) all_groups = DjangoFilterConnectionField(GroupNode) my_groups = DjangoFilterConnectionField(GroupNode) group_members = Node.Field(GroupMembersNode) all_group_members = DjangoFilterConnectionField(GroupMembersNode) def resolve_my_groups(self, args, context, info): if not context.user.is_authenticated(): return Group.objects.none() else: return Group.objects.filter(groupmembers__user=context.user, groupmembers__active=True, **args)
class Query(graphene.AbstractType): all_messages = DjangoFilterConnectionField(MessageType) all_customers = DjangoFilterConnectionField(CustomerType) current_user = graphene.Field(UserType) def resolve_all_messages(self, info, **kwargs): return models.Message.objects.all() def resolve_all_customers(self, info, **kwargs): return models.Customer.objects.all() def resolve_current_user(self, info, **kwargs): print("resolve_current_user") if not info.context.user.is_authenticated: print("resolve_current_user not authenticated") return None return info.context.user
class Query(graphene.ObjectType): event_rsvps = DjangoFilterConnectionField(EventRSVPNode) def resolve_event_rsvps(self, info, **kwargs): return EventRSVP.objects \ .order_by('event__date_time') \ .filter(event__date_time__gt=timezone.now()) \ .filter(**kwargs) \ .select_related('event', 'event__artist')
class Query(AbstractType): profile = Node.Field(ProfileNode) all_profiles = DjangoFilterConnectionField(ProfileNode) my_profile = graphene.Field(ProfileNode) profile_image = Node.Field(ProfileImageNode) all_profile_images = DjangoFilterConnectionField(ProfileImageNode) my_account = graphene.Field(AccountNode) def resolve_my_profile(self, args, context, info): if not context.user.is_authenticated(): return ProfileModel.objects.none() else: return ProfileModel.objects.get(user=context.user) def resolve_my_account(self, args, context, info): if not context.user.is_authenticated(): return User.objects.none() else: return context.user
class Query(object): all_messages = graphene.List(MessageType) all_messages_filtered = DjangoFilterConnectionField(MessageType) def resolve_all_messages(self, info, **kwargs): return models.Message.objects.all() def resolve_all_messages_filtered(self, info, **kwargs): return models.Message.objects.all()
class Query(graphene.AbstractType): clientes = DjangoFilterConnectionField(ClienteType) allclientes = graphene.List(ClienteType) def resolve_allclientes(self, info, **kwargs): return Cliente.objects.all() def resolve_clientes(self, info, **kwargs): return Cliente.objects.all()
class Query(graphene.ObjectType): # hello query to check is_authenticated or not hello = graphene.String(name=graphene.String(default_value="stranger")) user_by_id = graphene.Field(UserType, id=graphene.Int()) profile_by_id = graphene.Field(ProfileType, id=graphene.Int()) users = DjangoFilterConnectionField(UserType) profiles = DjangoFilterConnectionField(ProfileType) # our Resolver method takes the GraphQL context (root, info) as well as # Argument (name) for the Field and returns data for the query Response def resolve_hello(root, info, name): is_authenticated = info.context.user.is_authenticated return f'Hello {name} you are logged in : {is_authenticated}' def resolve_user_by_id(root, info, id): return User.objects.get(id=id) def resolve_profile_by_id(root, info, id): return Profile.objects.get(id=id)
class Query(AbstractType): community = Node.Field(CommunityNode) all_communities = DjangoFilterConnectionField(CommunityNode) community_user_profile = Node.Field(CommunityUserProfileNode) all_community_user_profiles = DjangoFilterConnectionField( CommunityUserProfileNode) my_communities = DjangoFilterConnectionField(CommunityNode) post = Node.Field(PostNode) all_posts = DjangoFilterConnectionField(PostNode) post_image = Node.Field(PostImageNode) all_post_images = DjangoFilterConnectionField(PostImageNode) def resolve_my_communities(self, args, context, info): if not context.user.is_authenticated(): return CommunityModel.objects.none() else: return CommunityModel.objects.filter( communityuserprofile__user=context.user, communityuserprofile__active=True, **args)
class Query(graphene.ObjectType): post = graphene.Node.Field(PostType, username=graphene.String()) all_posts = DjangoFilterConnectionField( PostType, id=graphene.ID(), username=graphene.String(required=True), q=graphene.String(), tags=graphene.String()) all_tags = graphene.List(Tags, username=graphene.String()) def resolve_current_user(self, args, context, info): if not context.user.is_authenticated(): return None return context.user # This is weird. Passing args with graphene: # https://github.com/graphql-python/graphene/issues/378#issuecomment-352206929 # @login_required def resolve_all_tags(self, info, **kwargs): info.context.args = dict(username=kwargs.get("username")) return [Tags()] # https://stackoverflow.com/a/39774434/41829 def resolve_all_posts(self, info, **kwargs): username = kwargs.get('username') u = User.objects.get(username=username) searchterm = kwargs.get('q') tags = kwargs.get('tags') id = kwargs.get('id') if id: rid = from_global_id(id)[1] return (FeedPost.objects.all().filter(pk=rid)) if tags: users_sources = FeedSource.objects.filter(user=u, tags=tags, show_on_frontpage=True) else: users_sources = FeedSource.objects.filter(user=u, show_on_frontpage=True) if searchterm: queryset = FeedPost.objects.filter( feed__feedsource__in=users_sources).filter( Q(title__icontains=searchterm) | Q(content__icontains=searchterm)).annotate( source_title=F('feed__feedsource__title')) else: queryset = FeedPost.objects.filter( feed__feedsource__in=users_sources).annotate( source_title=F('feed__feedsource__title')) return queryset
class Query(graphene.AbstractType): all_messages = DjangoFilterConnectionField(MessageType) message = graphene.Field(MessageType, id=graphene.ID()) def resolve_all_messages(self, args, context, info): return models.Message.objects.all() def resolve_message(self, args, context, info): from graphql_relay.node.node import from_global_id pk = from_global_id(args.get('id'))[1] return models.Message.objects.get(pk=pk)
class Queries(graphene.ObjectType): users = DjangoFilterConnectionField(UserQuery) user = graphene.Field(UserQuery) profile = graphene.Field(ProfileQuery) @staticmethod @login_required def resolve_user(info): return info.context.user @staticmethod @login_required def resolve_profile(info): return Profile.objects.get(user=info.context.user)
class Query(graphene.ObjectType): id = graphene.Field(MessageType, input=UserInput()) def resolve_message(self, info, input): id = input.get('id') # rid = from_global_id(args.get('id')) # rid is a tuple: ('MessageType', '1') # return models.Message.objects.get(pk=rid[1]) return Message.objects.get(pk=id) all_messages = DjangoFilterConnectionField(MessageType) def resolve_all_messages(self, *args): return models.Message.objects.all()
class Query(graphene.AbstractType): ''' The query schema for this app''' all_products = graphene.List(ProductType, available_only=graphene.Boolean()) all_carts = DjangoFilterConnectionField(CartType) cart = CartNode.Field(CartType) def resolve_all_products(self, args, available_only=False, **kwargs): if available_only is True: return models.Product.objects.filter(inventory_count__gt=0) return models.Product.objects.all() def resolve_all_carts(self, args, **kwargs): return models.Cart.objects.all()
class Query(g.AbstractType): current_user = g.Field(UserType) message = g.Field(MessageType, id=g.ID()) all_messages = DjangoFilterConnectionField(MessageType) def resolve_current_user(self, args, context, info): if not context.user.is_authenticated(): return None return context.user def resolve_message(self, args, context, info): rid = from_global_id(args.get('id')) return Message.objects.get(pk=rid[1]) def resolve_all_messages(self, args, context, info): return Message.objects.all()
class Query(graphene.AbstractType): current_user = graphene.Field(UserType) def resolve_current_user(self, args, context, info): if not context.user.is_authenticated(): return None return context.user message = graphene.Field(MessageType, id=graphene.ID()) def resolve_message(self, args, context, info): rid = from_global_id(args.get('id')) #rid is a tuple: ('MessageType', '1') return models.Message.objects.get(pk=rid[1]) #all_messages = graphene.List(MessageType) all_messages = DjangoFilterConnectionField(MessageType) def resolve_all_messages(self, args, context, info): return models.Message.objects.all()
class Query(graphene.AbstractType): all_messages = DjangoFilterConnectionField(MessageType) current_user = graphene.Field(UserType, id=graphene.Int(), name=graphene.String()) message = graphene.Field(MessageType, id=graphene.ID(), message=graphene.String()) def resolve_all_messages(self, info, **kwargs): return models.Message.objects.all() def resolve_message(self, info, id): rid = from_global_id(id) return models.Message.objects.get(pk=rid[1]) def resolve_current_user(self, info, **kwargs): context = info.context if not context.user.is_authenticated: return None return context.user
class Query(object): all_tests = DjangoFilterConnectionField(TestType) def resolve_all_tests(self, info, **kwargs): return Test.objects.all() user_tests = DjangoFilterConnectionField(TestType) def resolve_user_tests(self, info, **kwargs): user = info.context.user if not user.is_authenticated: return Test.objects.none() user_tests_ids = list( TestResult.objects.filter(user=user).values_list('test', flat=True)) accessible_tests_ids = list( Test.objects.filter( status=Test.STATUS_OPEN, start_at__lte=timezone.now(), end_at__gte=timezone.now(), accessible_by=Test.ACCESSIBLE_BY_ANYONE).values_list( 'id', flat=True)) test_ids = set(user_tests_ids + accessible_tests_ids) results = Test.objects.filter( pk__in=test_ids).order_by('-start_at').all() # TODO filter results here return results test = graphene.Field(TestType, id=graphene.ID(), uuid=graphene.String(), name=graphene.String()) def resolve_test(self, info, uuid): return Test.objects.get(uuid=uuid) test_result = graphene.Field(TestResultType, id=graphene.ID(), uuid=graphene.String(), user_id=graphene.String()) def resolve_test_result(self, info, uuid, user_id=None): user = info.context.user if not user.is_authenticated: return None # Use User based on `user_id` if current user is_staff=True test_user = user if user_id and user.is_staff: try: test_user = User.objects.get(id=user_id) except User.DoesNotExist: return None result = TestResult.objects.filter(user=test_user, uuid=uuid).first() if result and not user.is_staff and user != result.user: return None return result test_questions = DjangoFilterConnectionField(QuestionType) def resolve_test_questions(self, info, **kwargs): return Question.objects.all() current_user = graphene.Field(UserType) def resolve_current_user(self, info, **kwargs): context = info.context if not context.user.is_authenticated: return None return context.user
class UserQuery(graphene.ObjectType): user = graphene.relay.Node.Field(UserNode) users = DjangoFilterConnectionField(UserNode)
class Query(graphene.AbstractType): all_messages = DjangoFilterConnectionField(MessageType) def resolve_all_messages(self, context, **kwargs): return models.Message.objects.all()
class Query: problems = DjangoFilterConnectionField(types.ProblemNode)
class Query(graphene.ObjectType): all_import = DjangoFilterConnectionField( AssetImportFactsNode, filterset_class=AssetImportFilter, description="Método que retorna os objetos do tipo importação") all_export = DjangoFilterConnectionField( AssetExportFactsNode, filterset_class=AssetExportFilter, description="Método que retorna os objetos do tipo exportação") all_tradeBlocs = DjangoFilterConnectionField( TradeBlocsType, description="Método que retorna os registros de blocos econômicos") all_country = DjangoFilterConnectionField( CountryType, description="Método que retorna os países registrados") all_federativeUnit = DjangoFilterConnectionField( FederativeUnitType, description="Método que retorna as unidades federativas registradas") all_transportation = DjangoFilterConnectionField( TransportationType, description="Método que retorna as vias de trasportação cadastradas") all_urf = DjangoFilterConnectionField( UrfType, description="Método que retorna as URFs registradas") all_ncm = DjangoFilterConnectionField( NCMType, description="Método que retorna os NCMs dos registros") all_cuci = DjangoFilterConnectionField( CUCIType, description="Método que retorna as nomenclaturas CUCI registradas") all_cgce = DjangoFilterConnectionField( CGCEType, description="Método que retorna as nomenclaturas CGCE registradas") all_sh = DjangoFilterConnectionField( SHType, description="Método que retorna as nomenclaturas SH registradas") aggregated_import_transportation = DjangoFilterConnectionField( Aggregated_Import, filterset_class=AssetImportFilter) aggregated_import_urf = DjangoFilterConnectionField( Aggregated_Import, filterset_class=AssetImportFilter) aggregated_import_date = DjangoFilterConnectionField( Aggregated_Import, filterset_class=AssetImportFilter) aggregated_import_country = DjangoFilterConnectionField( Aggregated_Import, filterset_class=AssetImportFilter) aggregated_import_trade_bloc = DjangoFilterConnectionField( Aggregated_Import, filterset_class=AssetImportFilter) aggregated_export_transportation = DjangoFilterConnectionField( Aggregated_Export, filterset_class=AssetExportFilter) aggregated_export_urf = DjangoFilterConnectionField( Aggregated_Export, filterset_class=AssetExportFilter) aggregated_export_date = DjangoFilterConnectionField( Aggregated_Export, filterset_class=AssetExportFilter) aggregated_export_country = DjangoFilterConnectionField( Aggregated_Export, filterset_class=AssetExportFilter) aggregated_export_trade_bloc = DjangoFilterConnectionField( Aggregated_Export, filterset_class=AssetExportFilter) def resolve_all_import(self, info, **kwargs): return AssetImportFacts.objects.all() def resolve_all_export(self, info, **kwargs): return AssetExportFacts.objects.all() def resolve_all_ncm(self, info, **kwargs): return NCM.objects.all() def resolve_all_tradeBlocs(self, info, **kwargs): return TradeBlocs.objects.all() def resolve_all_country(self, info, **kwargs): return Country.objects.all() def resolve_all_federativeUnit(self, info, **kwargs): return FederativeUnit.objects.all() def resolve_all_transportation(self, info, **kwargs): return Transportation.objects.all() def resolve_all_urf(self, info, **kwargs): return Urf.objects.all() def resolve_all_cuci(self, info, **kwargs): return CUCI.objects.all() def resolve_all_cgce(self, info, **kwargs): return CGCE.objects.all() def resolve_all_sh(self, info, **kwargs): return SH.objects.all() def resolve_aggregated_import_transportation(self, info, **kwargs): return list(AssetImportFacts.objects.raw( '''SELECT b.[id], a.[transportation_code], a.[transportation_name] FROM assets_Transportation a INNER JOIN assets_AssetImportFacts b ON a.[transportation_code]=b.[transportation_id] GROUP BY a.[transportation_name]''')) def resolve_aggregated_import_urf(self, info, **kwargs): return list(AssetImportFacts.objects.raw( '''SELECT b.[id], a.[urf_code], a.[urf_name] FROM assets_Urf a INNER JOIN assets_AssetImportFacts b ON a.[urf_code]=b.[urf_id] GROUP BY a.[urf_name]''')) def resolve_aggregated_import_date(self, info, **kwargs): return list(AssetImportFacts.objects.raw('''Select id, COUNT(date) FROM assets_AssetImportFacts GROUP BY date''')) def resolve_aggregated_import_country(self, info, **kwargs): return list(AssetImportFacts.objects.raw( '''SELECT b.[id], a.[id], a.[country_name_pt] FROM assets_Country a INNER JOIN assets_AssetImportFacts b ON a.[id]=b.[origin_country_id] GROUP BY a.[country_name_pt]''')) def resolve_aggregated_import_trade_bloc(self, info, **kwargs): return list(AssetImportFacts.objects.raw( '''SELECT c.[bloc_code], c.[bloc_name_pt], b.[origin_country_id], a.[id], a.[trade_bloc_id] FROM assets_AssetImportFacts b INNER JOIN assets_Country a ON a.[id]=b.[origin_country_id] INNER JOIN assets_TradeBlocs c ON c.[bloc_code]=a.[trade_bloc_id] GROUP BY c.[bloc_name_pt]''')) def resolve_aggregated_export_transportation(self, info, **kwargs): return list(AssetExportFacts.objects.raw( '''SELECT b.[id], a.[transportation_code], a.[transportation_name] FROM assets_Transportation a INNER JOIN assets_AssetExportFacts b ON a.[transportation_code]=b.[transportation_id] GROUP BY a.[transportation_name]''')) def resolve_aggregated_export_urf(self, info, **kwargs): return list(AssetExportFacts.objects.raw( '''SELECT b.[id], a.[urf_code], a.[urf_name] FROM assets_Urf a INNER JOIN assets_AssetExportFacts b ON a.[urf_code]=b.[urf_id] GROUP BY a.[urf_name]''')) def resolve_aggregated_export_date(self, info, **kwargs): return list(AssetExportFacts.objects.raw('''Select id, COUNT(date) FROM assets_AssetExportFacts GROUP BY date''')) def resolve_aggregated_export_country(self, info, **kwargs): return list(AssetExportFacts.objects.raw( '''SELECT b.[id], a.[id], a.[country_name_pt] FROM assets_Country a INNER JOIN assets_AssetExportFacts b ON a.[id]=b.[destination_country_id] GROUP BY a.[country_name_pt]''')) def resolve_aggregated_export_trade_bloc(self, info, **kwargs): return list(AssetExportFacts.objects.raw( '''SELECT c.[bloc_code], c.[bloc_name_pt], b.[destination_country_id], a.[id], a.[trade_bloc_id] FROM assets_AssetExportFacts b INNER JOIN assets_Country a ON a.[id]=b.[destination_country_id] INNER JOIN assets_TradeBlocs c ON c.[bloc_code]=a.[trade_bloc_id] GROUP BY c.[bloc_name_pt]'''))
class Query(ObjectType): animal = relay.Node.Field(AnimalNode) all_animals = DjangoFilterConnectionField(AnimalNode) #custom filter passed as argument all_animals_customfilter = DjangoFilterConnectionField( AnimalNode, filterset_class=AnimalFilter)
class Query(graphene.ObjectType): message = Node.Field(MessageType) all_messages = DjangoFilterConnectionField(MessageType)
class Query(graphene.AbstractType): all_messages = DjangoFilterConnectionField(MessageType) def resolve_all_messages(self, info): return Message.objects.all()
def Assemble(resource): class ObjectMeta: model = resource.model name = resource.model._meta.object_name fields = list(resource.gql_fields.keys()) filter_fields = resource.filterset.filter_fields interfaces = (graphene.relay.Node,) convert_choices_to_enum = False resolvers = {} for name, _type in resource.property_map.items(): def get_property(name): def property_resolver(obj, info): return getattr(obj, name)() return property_resolver resolvers[name] = _type(resolver=get_property(name)) @classmethod def get_queryset(cls, queryset, info): qs, audit = resource.get_permitted_queryset( "list", user=(info.context.user.is_authenticated and info.context.user or None), qs=queryset, ) return qs @classmethod def get_node(cls, info, id): obj, audit = resource.get_permitted_object( id, "detail", user=(info.context.user.is_authenticated and info.context.user or None), ) return obj ObjectType = type( ObjectMeta.name, (DjangoObjectType,), { "Meta": ObjectMeta, **resolvers, "get_queryset": get_queryset, "get_node": get_node, }, ) class MutationMeta: serializer_class = resource.serializer_class.Assemble(resource, "id") model = resource.model name = "%sMutation" % resource.model._meta.object_name fields = list(resource.gql_fields.keys()) convert_choices_to_enum = False Mutation = type(MutationMeta.name, (SerializerMutation,), {"Meta": MutationMeta}) stub = "".join( part.capitalize() for part in resource.model._meta.verbose_name.split(" ") ) plural = "".join( part.capitalize() for part in resource.model._meta.verbose_name_plural.split(" ") ) list_view = "all_%s" % plural detail_view = stub gql_list = DjangoFilterConnectionField(ObjectType) gql_detail = graphene.relay.Node.Field(ObjectType) EasyQuery = type( "%sQuery" % ObjectMeta.name, (object,), {detail_view: gql_detail, list_view: gql_list}, ) EasyMutations = type( "%sMutations" % ObjectMeta.name, (object,), {"create_%s" % stub: Mutation.Field()}, ) return ObjectType, EasyQuery, None and EasyMutations