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)
