class Query(object): stud = Node.Field(StudNode) all_stud = DjangoFilterConnectionField(StudNode) ingredient = Node.Field(IngredientNode) all_ingredients = DjangoFilterConnectionField(IngredientNode)
class UsersQuery(object): user = Node.Field(types.UserNode) all_users = DjangoFilterConnectionField( types.UserNode, filterset_class=filters.UserFilter, ) auth_group = Node.Field(types.AuthGroupNode) all_auth_groups = DjangoFilterConnectionField( types.AuthGroupNode, filterset_class=filters.AuthGroupFilter, ) auth_permission = Node.Field(types.AuthPermissionNode) all_auth_permissions = DjangoFilterConnectionField( types.AuthPermissionNode, filterset_class=filters.AuthPermissionFilter, ) content_type = Node.Field(types.ContentTypeNode) all_content_types = DjangoFilterConnectionField( types.ContentTypeNode, filterset_class=filters.ContentTypeFilter, ) current_user = Field(types.UserNode) def resolve_current_user(self, info): if info.context.user.is_authenticated: return info.context.user
class Query(AbstractType): user = Node.Field(UserNode) all_users = DjangoFilterConnectionField(UserNode) developer = Node.Field(DeveloperNode) all_developers = DjangoFilterConnectionField(DeveloperNode) project = Node.Field(ProjectNode) all_projects = DjangoFilterConnectionField(ProjectNode)
def _wrapper(node): node_name = node.__name__.lower()[:-4] meta = query._meta meta.fields[node_name] = Node.Field(node) meta.fields['all_' + node_name] = DjangoFilterConnectionField(node) query._meta.fields[node_name] = Node.Field(node) setattr(query, '_meta', meta) return node
class Query(graphene.ObjectType): class Meta: abstract = True client = Node.Field(ClientType) all_clients = DjangoFilterConnectionField(ClientType) project = Node.Field(ProjectType) all_projects = DjangoFilterConnectionField(ProjectType)
class Query(graphene.ObjectType): user = Node.Field(UserNode) users = DjangoFilterConnectionField(UserNode) officer = Node.Field(OfficerNode) officers = DjangoFilterConnectionField(OfficerNode) officer_position = Node.Field(OfficerNode) officer_positions = DjangoFilterConnectionField(OfficerNode)
class RecipesQuery(object): recipe = Node.Field(types.RecipeNode) all_recipes = DjangoFilterConnectionField( types.RecipeNode, filterset_class=filters.RecipeFilter, ) ingredient = Node.Field(types.IngredientNode) all_ingredients = DjangoFilterConnectionField( types.IngredientNode, filterset_class=filters.IngredientFilter, ) step = Node.Field(types.StepNode) all_steps = DjangoFilterConnectionField( types.StepNode, filterset_class=filters.StepFilter, ) recipe_step_relationship = Node.Field(types.RecipeStepRelationshipNode) all_recipe_step_relationships = DjangoFilterConnectionField( types.RecipeStepRelationshipNode, filterset_class=filters.RecipeStepRelationshipFilter, ) def resolve_all_recipes(self, info, **kwargs): down_vote = getattr(ACTIVITY_TYPES, 'down_vote') up_vote = getattr(ACTIVITY_TYPES, 'up_vote') comments_filter = Q(comments__active=True) down_votes_filter = (Q(user_activities__active=True) & Q(user_activities__activity_type=down_vote)) up_votes_filter = (Q(user_activities__active=True) & Q(user_activities__activity_type=up_vote)) total_steps = Count('steps', distinct=True) total_ingredients = Count('ingredients', distinct=True) total_comments = Count('comments', filter=comments_filter, distinct=True) total_down_votes = Count('user_activities', filter=down_votes_filter, distinct=True) total_up_votes = Count('user_activities', filter=up_votes_filter, distinct=True) return Recipe.objects \ .select_related('author') \ .annotate(total_steps=total_steps) \ .annotate(total_ingredients=total_ingredients) \ .annotate(total_comments=total_comments) \ .annotate(total_down_votes=total_down_votes) \ .annotate(total_up_votes=total_up_votes) \ .all()
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(graphene.ObjectType): user = Node.Field(UserNode) cat = Node.Field(CatNode) dog = Node.Field(DogNode) mice = Node.Field(MouseNode) all_users = DjangoConnectionField(UserNode) all_cats = DjangoConnectionField(CatNode) all_dogs = DjangoConnectionField(DogNode) all_mice = DjangoConnectionField(MouseNode)
class Query(graphene.ObjectType): class Meta: abstract = True client = Node.Field(ClientType) all_clients = DjangoFilterConnectionField(ClientType) employee = Node.Field(EmployeeType) all_employees = DjangoFilterConnectionField(EmployeeType) office = Node.Field(OfficeType) all_offices = DjangoFilterConnectionField(OfficeType)
class Query(object): game = Node.Field(Game) all_games = DjangoFilterConnectionField(Game) item = Node.Field(Item) all_items = DjangoFilterConnectionField(Item) recipe = Node.Field(Recipe) all_recipes = DjangoFilterConnectionField(Recipe) station = Node.Field(Station) all_stations = DjangoFilterConnectionField(Station)
class Query(object): all_seasons = graphene.List(SeasonType) all_skins = graphene.List(SkinType) """ Skins will return one result matching the search""" skins = graphene.Field(SkinType, id=graphene.Int(), name = graphene.String(), rarity = graphene.String(), price = graphene.Int(), first_seen = graphene.String() ) fortniteskins = Node.Field(RarityNode) all_rarity = DjangoFilterConnectionField(RarityNode) skins_price = Node.Field(PriceNode) all_price = DjangoFilterConnectionField(PriceNode) def resolve_all_seasons(self, info, **kwargs): return season.objects.all() def resolve_all_skins(self, info, **kwargs): return fortniteskins.objects.all() def resolve_skins(self, info, **kwargs): id = kwargs.get('id') name = kwargs.get('name') rarity = kwargs.get('rarity') price = kwargs.get('price') first_seen = kwargs.get('first_seen') outfit_img = kwargs.get('outfit_img') if id is not None: return fortniteskins.objects.get(pk=id) if name is not None: return fortniteskins.objects.get(name=name) if rarity is not None: return fortniteskins.objects.get(rarity=rarity) if price is not None: return fortniteskins.objects.get(price=price) if first_seen is not None: return fortniteskins.objects.get(first_seen=first_seen) if outfit_img is not None: return fortniteskins.objects.get(outfit_img=outfit_img) return None
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(object): user = Node.Field(UserNode) all_users = DjangoFilterConnectionField(UserNode) account = Node.Field(AccountNode) all_accounts = DjangoFilterConnectionField(AccountNode) cashier = Node.Field(CashierNode) all_cashiers = DjangoFilterConnectionField(CashierNode) clasification = Node.Field(ClasificationNode) all_clasifications = DjangoFilterConnectionField(ClasificationNode) transaction = Node.Field(TransactionNode) all_transactions = DjangoFilterConnectionField(TransactionNode)
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 Query(ObjectType): app = Node.Field(AppType) all_apps = DjangoFilterConnectionField(AppType) like = Node.Field(AppLikeType) all_likes = DjangoFilterConnectionField(AppLikeType) seerah_question = Node.Field(SeerahQuestionType) all_seerah_questions = DjangoFilterConnectionField(SeerahQuestionType) seerah_topic = Node.Field(SeerahTopicType) all_seerah_topics = DjangoFilterConnectionField(SeerahTopicType) dictionary = Node.Field(DictionaryType) all_dis = DjangoFilterConnectionField(DictionaryType)
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(object): wizard = Node.Field(WizardNode) wizards = DjangoFilterConnectionField(WizardNode) places = DjangoFilterConnectionField(PlaceNode) spells = DjangoFilterConnectionField(SpellNode) # def resolve_wizard(self, info, *args, **kwargs): # id = kwargs.get('id') # name = kwargs.get('name') # # if id is not None: # return Wizard.objects.prefetch_related('known_spells').get(pk=id) # if name is not None: # return Wizard.objects.prefetch_related('known_spells').get(name=name) # # return None def resolve_wizards(self, info, *args, **kwargs): return Wizard.objects.all() def resolve_places(self, info): return Place.objects.all() def resolve_spells(self, info): return Spell.objects.all()
class MessageQuery(object): message = Node.Field(types.MessageNode) all_messages = fields.ProtectedConnectionField( types.MessageNode, filterset_class=filters.MessageFilter, )
class Query(graphene.ObjectType): node = Node.Field() songs = CustomField(SongNodeConnection) artists = CustomField(ArtistNodeConnection) tags = CustomField(TagNodeConnection) links = CustomField(LinkNodeConnection) ratings = CustomField(RatingNodeConnection) login = Field(graphene.Boolean, username=graphene.String(), password=graphene.String()) def resolve_login(self, info, username, password): user = UserModel.query.get(username) if user is None: return False if user.password == password: return True return False get_discord_user = Field(lambda: User, discord_id=BigInt()) def resolve_get_discord_user(self, info, discord_id): return UserDiscordModel.query.get(discord_id).user
class Query(graphene.AbstractType): all_families = DjangoFilterConnectionField(FamilyType) all_locations = DjangoFilterConnectionField(LocationType) all_products = DjangoFilterConnectionField(ProductType) all_transactions = DjangoFilterConnectionField(TransactionType) product = Node.Field(ProductType)
class Query(object): me = graphene.Field(User) @staticmethod def resolve_me(root, info): if info.context.user.is_authenticated: return info.context.user else: return None user = Node.Field(User) users = graphene.List( User, description="用户列表", args={ 'username': graphene.String(required=False, description="账号"), 'is_active': graphene.Boolean(required=False, description="状态,开启或关闭") }, ) @staticmethod def resolve_users(root, info, **kwargs): query = Q(is_superuser=False) if 'username' in kwargs and kwargs['username']: username = kwargs.pop('username') query &= Q(username__icontains=username) if 'is_active' in kwargs: query &= Q(is_active=bool(kwargs['is_active'])) users = models.User.objects.filter(query) return users
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)
def add_graphql_to_class(model, filter_fields, query_class): _model = model _filter_fields = filter_fields if hasattr(_model._meta, "app_label"): app_label = getattr(_model._meta, "app_label") else: app_label = "" # class __Model(DjangoObjectType): class Meta: nonlocal _model, _filter_fields model = _model interfaces = (Node, ) filter_fields = _filter_fields _Model = type( app_label + "__" + _model.__name__ + "__class", (DjangoObjectType, ), {"Meta": Meta}, ) setattr(query_class, app_label + "__" + _model.__name__, Node.Field(_Model)) setattr( query_class, app_label + "__" + _model.__name__ + "All", DjangoFilterConnectionField(_Model), )
class Query(AbstractType): all_pessoas = DjangoFilterConnectionField(PessoaNode) def resolve_all_products(self, args, context, info): return Pessoa.objects.all() tipo = Node.Field(TipoNode) all_tipo = DjangoFilterConnectionField(TipoNode)
class UserQuery(graphene.ObjectType): all_users = DjangoFilterConnectionField(UserNode) filter_user = CustomDjangoFilterConnectionField(UserNode, filterset_class=UserFilter) user = Node.Field(UserNode) def resolve_all_users(self, info): return User.objects.all()
class TeamQuery(graphene.ObjectType): all_teams = DjangoFilterConnectionField(TeamNode) filter_team = CustomDjangoFilterConnectionField(TeamNode, filterset_class=TeamFilter) team = Node.Field(TeamNode) def resolve_all_teams(self, info): return Team.objects.all()
class Queries(ObjectType): # without id resolver # category = Field(CategoryNode) # without `graphene.relay.node#Node.node_resolver` # category = Field( # CategoryNode, # id=Argument(ID, required=True, description="ID of the category."), # description="Look up a category by ID.", # ) category = Node.Field(CategoryNode) all_categories = DjangoFilterConnectionField(CategoryNode) ingredient = Node.Field(IngredientNode) """ standard scalar filter query { allIngredients(name_Icontains: "g", first: 3, orderBy: "-name") { edges { node { id name } } } } """ """ custom scalar filter query { allIngredients( name_Icontains: "g", nameLenGt: 4, first: 3, orderBy: "-name") { edges { node { id name } } } } """ all_ingredients = DjangoFilterConnectionField( IngredientNode, filterset_class=IngredientFilterSet)
class Query(graphene.ObjectType): dataset = Node.Field(DatasetNode) datasets = DjangoFilterConnectionField(DatasetNode) label = Node.Field(LabelNode) labels = DjangoFilterConnectionField(LabelNode) def resolve_datasets(self, info): user = info.context.user if not user.is_authenticated: return models.Dataset.objects.filter(is_public=True) else: return models.Dataset.objects.exclude(is_public=True).filter( Q(user=user) | Q(admins__id=user.id) | Q(contributors__id=user.id)).distinct() def resolve_labels(self): return models.Label.objects.none()
class CircuitsQuery(AbstractType): providers = DjangoFilterConnectionField(ProviderNode) circuit_types = DjangoFilterConnectionField(CircuitTypeNode) circuit = Node.Field(CircuitNode) circuits = DjangoFilterConnectionField(CircuitNode) circuit_terminations = DjangoFilterConnectionField(CircuitTerminationNode)