class SocietyNode(DjangoObjectType): cover = Field(ImageType) upcoming_events = DjangoConnectionField(EventNode, max_limit=5) past_news = DjangoConnectionField(NewsNode, max_limit=5) class Meta: model = Society fields = ('name', 'slug', 'secretary', 'joint_secretary', 'description', 'mentor', 'club_set', 'cover', 'report_link', 'is_active', 'gallery', 'custom_html') filter_fields = ('slug', 'is_active') interfaces = (relay.Node, ) def resolve_cover(self, info): return ImageType( sizes=build_image_types(info.context, self.cover, 'festival')) def resolve_club_set(self, info, *args, **kwargs): return self.club_set.filter(published=True) def resolve_upcoming_events(self, info, *args, **kwargs): return Event.objects.filter(club__society=self).filter( published=True).filter( date__gte=timezone.now())[:kwargs.get('first', 5)] def resolve_past_news(self, info, *args, **kwargs): return News.objects.filter(club__society=self)[:kwargs.get('first', 5)]
class Query(graphene.ObjectType): # NODO GENERICO node = graphene.Node.Field() # Player players = DjangoConnectionField( User, description="all players" ) player = graphene.Node.Field(User) # Team # Player teams = DjangoConnectionField( Team, description="all teams" ) team = graphene.Node.Field(Team) tournaments = DjangoConnectionField( Tournament, description="all tournaments" ) tournament = graphene.Node.Field(Tournament)
class Query(ObjectType): all_images = DjangoFilterConnectionField( ImageNode, filterset_class=ImageFilter, description="Get top results of images") all_tags = DjangoConnectionField(TagNode, description="Get the list of all tags") all_users = DjangoConnectionField( UserNode, description="Get the list of all the users") user = relay.Node.Field( UserNode, description="Get a single user from global user id") image = relay.Node.Field( ImageNode, description="Get a single image from an global image id.") tag = relay.Node.Field( TagNode, description="Get a single tag from a global tag id.") """ query for searching among the image database based on a search query """ search_images = graphene.List( ImageNode, search_query=graphene.String(required=False), description="Get list of images based on a search query.") """ resolver for search image query it uses django's optimized quering to filter out the results """ def resolve_search_images(self, info, search_query, **kwargs): from django.db.models import Q qs = ImageHandler.objects.filter( Q(title__icontains=search_query) | Q(user__username__icontains=search_query) | Q(tags__tag__icontains=search_query)) return qs
class OrderNode(DjangoObjectType): customer = graphene.Field(ProfileNode, required=True) product = graphene.Field(ProductUnion) lease = graphene.Field(LeaseUnion) status = OrderStatusEnum(required=True) comment = graphene.String() price = graphene.Decimal(required=True) tax_percentage = graphene.Decimal(required=True) pretax_price = graphene.Decimal(required=True) total_price = graphene.Decimal(required=True) total_pretax_price = graphene.Decimal(required=True) total_tax_percentage = graphene.Decimal(required=True) due_date = graphene.Date() order_lines = DjangoConnectionField(OrderLineNode, required=True) log_entries = DjangoConnectionField(OrderLogEntryNode, required=True) paid_at = graphene.DateTime( description="Date when the order was paid (if it has been paid)") cancelled_at = graphene.DateTime( description="Date when the order was cancelled by the admins") rejected_at = graphene.DateTime( description="Date when the order was rejected by the customer") class Meta: model = Order interfaces = (graphene.relay.Node, ) connection_class = CountConnection exclude = ( "_product_content_type", "_product_object_id", "_lease_content_type", "_lease_object_id", ) @classmethod @login_required def get_queryset(cls, queryset, info): user = info.context.user return return_queryset_if_user_has_permissions( queryset, user, Order, BerthLease, WinterStorageLease, CustomerProfile, ) @classmethod @login_required def get_node(cls, info, id): node = super().get_node(info, id) return return_node_if_user_has_permissions( node, info.context.user, Order, CustomerProfile, BerthLease, WinterStorageLease, )
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 TimetableNode(DjangoObjectType): original_id = graphene.Int() vendors = DjangoConnectionField(lambda: VendorNode) admins = DjangoConnectionField(lambda: UserNode) class Meta: model = Timetable interfaces = (graphene.relay.Node, ) def resolve_original_id(self, args, context, info): return self.id
class PrivateQuery(KonnektQuery, PublicQuery): viewer = graphene.Field(UserNode) nodes = graphene.ConnectionField( SearchResultConnection, query=graphene.String(description='Value to search for'), node_type=NodeType(required=True)) topic = DjangoFilterConnectionField(TopicNode) profile = DjangoFilterConnectionField(UserProfileNode) topics_by_user = DjangoConnectionField(TopicNode) def resolve_viewer(self, info, *args): user = info.context.user if not user.is_authenticated: raise Exception('Not logged in!') return UserNode.get_node(info, id=user.id) def resolve_nodes(self, info, query=None, node_type=None, first=None, last=None, before=None, after=None): # TODO: Add logic to paginate search based on first, last, before and after params node = UserProfileNode if node_type == UserProfileNode else TopicNode return node.search(query, info) def resolve_topics_by_user(self, info): user = info.context.user.userprofile topics = Topic.objects.filter(answer__author=user) return topics
class Query(graphene.ObjectType): groups = DjangoFilterConnectionField(GroupT) content_types = DjangoFilterConnectionField(ContentTypeT) permissions = DjangoFilterConnectionField(PermissionT) notifications = DjangoFilterConnectionField(NotificationT) users = DjangoFilterConnectionField(UserT) links = DjangoConnectionField(LinkInternalT) activitys = DjangoFilterConnectionField(ActivityT) courses = DjangoFilterConnectionField(CourseT) semesters = DjangoFilterConnectionField(SemesterT) departments = DjangoFilterConnectionField(DepartmentT) answers = DjangoFilterConnectionField(AnswerT) questions = DjangoFilterConnectionField(QuestionT) survey_responses = DjangoFilterConnectionField(SurveyResponseT) surveys = DjangoFilterConnectionField(SurveyT) group = DjangoFilterConnectionField(GroupT) content_type = DjangoFilterConnectionField(ContentTypeT) permission = DjangoFilterConnectionField(PermissionT) notification = DjangoFilterConnectionField(NotificationT) user = graphene.relay.Node.Field(UserT) link = graphene.relay.Node.Field(LinkInternalT) activity = graphene.relay.Node.Field(ActivityT) course = graphene.relay.Node.Field(CourseT) semester = graphene.relay.Node.Field(SemesterT) department = graphene.relay.Node.Field(DepartmentT) answer = graphene.relay.Node.Field(AnswerT) question = graphene.relay.Node.Field(QuestionT) survey_response = graphene.relay.Node.Field(SurveyResponseT) survey = graphene.relay.Node.Field(SurveyT)
class ReporterNode(DjangoObjectType): articles = DjangoFilterConnectionField( 'starter.types.ArticleNode', description='Return a connection of Article.') dataloader_articles = DjangoConnectionField( 'starter.types.ArticleNode', description= 'Return Article connection which contains pagination and Article information using dataloader.' ) class Meta: model = Reporter interfaces = (Node, ) filterset_class = ReporterFilter connection_class = CountableConnectionBase fields = ['email', 'username', 'first_name', 'last_name', 'articles'] @staticmethod def resolve_articles(root: Reporter, info: ResolveInfo, **kwargs) -> QuerySet: return Article.objects.filter(reporter=root) @staticmethod def resolve_dataloader_articles(root: Reporter, info: ResolveInfo, **kwargs) -> Promise: return info.context.loaders.articles_by_reporter_loader.load(root.id)
class Query(ObjectType): notas = DjangoConnectionField(NotaType) personas = DjangoConnectionField(PersonaType) nota = Field(NotaType, id=Argument(ID, required=True)) def resolve_notas(root, info, **kwargs): return Nota.objects.all() def resolve_nota(root, info, **kwargs): return Nota.objects.get(id=kwargs.get('id')) def resolve_personas(root, info, **kwargs): return Persona.objects.all() def resolve_all_notas(root, info, **kwargs): return Nota.objects.select_related('persona').all()
class UserProfileNode(DjangoObjectType): user = UserNode() cover = Field(ImageType) avatar = Field(ImageType) social_links = DjangoConnectionField(SocialLinks) class Meta: filter_fields = [] model = UserProfile fields = ('id', 'user', 'email_confirmed', 'gender', 'roll', 'dob', 'prog', 'year', 'phone', 'hometown', 'branch', 'skills', 'about') interfaces = (relay.Node, ) def resolve_cover(self, info): from gymkhana.utils import build_image_types return ImageType( sizes=build_image_types(info.context, self.cover, 'festival')) def resolve_avatar(self, info): from gymkhana.utils import build_image_types return ImageType( sizes=build_image_types(info.context, self.avatar, 'festival')) def resolve_social_links(self, info): return SocialLink.objects.filter(user=self.user) @classmethod def search(cls, query, info): return cls._meta.model.objects.search(query)
class UserQuery(graphene.ObjectType): profile = graphene.Field(ProfileObject) user = graphene.Node.Field(UserObject) users = DjangoConnectionField(UserObject) def resolve_users(self, info, **kwargs): return User.objects.all().select_related('profile')
class Query(graphene.ObjectType): # all_categories = graphene.List(CategoryType) # all_ingredients = graphene.List(IngredientType) # category = relay.Node.Field(CategoryType) # ingredient = relay.Node.Field(IngredientType) all_categories = DjangoConnectionField(CategoryType) all_ingredients = DjangoConnectionField(IngredientType) category = graphene.Field(CategoryType, id=graphene.Int(), name=graphene.String()) ingredient = graphene.Field(IngredientType, id=graphene.Int(), name=graphene.String()) def resolve_all_categories(self, info, **kwargs): return Category.objects.all() def resolve_all_ingredients(self, info, **kwargs): return Ingredient.objects.select_related('category').all() def resolve_category(self, info, **kwargs): id = kwargs.get('id') name = kwargs.get('name') if id is not None: return Category.objects.get(pk=id) if name is not None: return Category.objects.get(name=name) return None def resolve_ingredient(self, info, **kwargs): id = kwargs.get('id') name = kwargs.get('name') if id is not None: return Ingredient.objects.get(pk=id) if name is not None: return Ingredient.objects.get(name=name) return None
class Query(ObjectType): persons = DjangoConnectionField(PersonType) person = Field(PersonType, id=Argument(ID, required=True)) def resolve_notes(root, info, **kwargs): return Person.objects.all() def resolve_note(root, info, **kwargs): return Person.objects.get(id=kwargs.get('id'))
class Query(ObjectType): notas = DjangoConnectionField(NotaType) nota = Field(NotaType, id=Argument(ID, required=True)) def resolve_notas(root, info, **kwargs): return Nota.objects.all() def resolve_nota(root, info, **kwargs): return Nota.objects.get(id=kwargs.get('id'))
class Query: users = DjangoConnectionField(types.UserNode) me = graphene.Field(types.UserNode) @staticmethod @login_required def resolve_me(root: None, info: ResolveInfo): assert info.context return info.context.user
class Query(ObjectType): hotels = DjangoConnectionField(HotelType) Hotel = Field(HotelType, id=Argument(ID, required=True)) def resolve_Hotels(root, info, **kwargs): return Hotel.objects.all() def resolve_Hotel(root, info, **kwargs): return Hotel.objects.get(id=kwargs.get('id'))
class QuestionNode(ObjectType): """ Question Node gives information about questions """ question_text = String() votes = DjangoConnectionField(UserNode) creator = Field(UserNode) choice_set = DjangoConnectionField(ChoiceNode) vote_count = Int() user_did_vote = Boolean() class Meta: interfaces = (relay.Node, ) def resolve_vote_count(self, info): return vote_loader.load(self.id).then(lambda votes: len(votes)) def resolve_votes(self, info): if not info.context.user.is_authenticated: return User.objects.none() return vote_loader.load(self.id).then(lambda votes: votes) def resolve_user_did_vote(self, info): if not info.context.user.is_authenticated: return False return vote_loader.load(self.id).then(lambda votes: info.context.user in votes ) def resolve_choice_set(self, info): return choice_loader.load(self.id) def resolve_question_text(self, info): return self.question_text def resolve_creator(self, info): return self.creator @classmethod def get_node(cls, info, id): return Question.objects.get(pk=id)
class Query(ObjectType): pacientes = DjangoConnectionField(PacienteType) paciente = Field(PacienteType, id=Argument(ID, required=True)) def resolve_pacientes(root, info, **kwargs): return Paciente.objects.all() def resolve_paciente(root, info, **kwargs): return Paciente.objects.get(id=kwargs.get('id'))
class EventNode(DjangoObjectType): original_id = graphene.Int() timetable = DjangoConnectionField(lambda: TimetableNode) class Meta: model = Event interfaces = (graphene.relay.Node, ) def resolve_original_id(self, args, context, info): return self.id
class UserProfileNode(DjangoObjectType): user = UserNode() cover = Field(ImageType) avatar = Field(ImageType) social_links = DjangoConnectionField(SocialLinks) gender = graphene.String() prog = graphene.String() branch = graphene.String() year = graphene.String() id = graphene.ID(required=True) class Meta: filter_fields = ['roll'] model = UserProfile fields = ('id', 'user', 'email_confirmed', 'gender', 'roll', 'dob', 'prog', 'year', 'phone', 'hometown', 'branch', 'skills', 'about') interfaces = (relay.Node, ) def resolve_cover(self, info): from gymkhana.utils import build_image_types return ImageType( sizes=build_image_types(info.context, self.cover, 'festival')) def resolve_avatar(self, info): from gymkhana.utils import build_image_types return ImageType( sizes=build_image_types(info.context, self.avatar, 'festival')) def resolve_social_links(self, info): return SocialLink.objects.filter(user=self.user) def resolve_gender(self, info): return self.user.userprofile.get_gender_display() def resolve_prog(self, info): return self.user.userprofile.get_prog_display() def resolve_branch(self, info): return self.user.userprofile.get_branch_display() def resolve_year(self, info): return self.user.userprofile.get_year_display() def resolve_id(self, info): return self.id @classmethod def search(cls, query, info): nodes = cls._meta.model.objects.search( query) if query else cls._meta.model.objects return nodes.all()
class Query(graphene.ObjectType): songs = DjangoConnectionField(SongType, songName=graphene.String()) albums = DjangoConnectionField(AlbumType, albumName=graphene.String()) artists = DjangoConnectionField(ArtistType, artistsName=graphene.String()) @graphene.resolve_only_args def resolve_songs(self, **kwargs): if kwargs == {}: return Song.objects.all() return Song.objects.first(pk=kwargs.get('songName')) @graphene.resolve_only_args def resolve_albums(self, **kwargs): if kwargs == {}: return Album.objects.all() return Album.objects.first(pk=kwargs.get('albumName')) @graphene.resolve_only_args def resolve_artists(self, **kwargs): if kwargs == {}: return Artist.objects.all() return Artist.objects.first(pk=kwargs.get('artistsName'))
class PublicQuery(graphene.ObjectType): node = relay.Node.Field() societies = DjangoFilterConnectionField(SocietyNode) clubs = DjangoFilterConnectionField(ClubNode) festivals = DjangoConnectionField(FestivalNode) home_carousel = graphene.Field(GalleryNode) home_gallery = graphene.Field(GalleryNode) def resolve_home_carousel(self, info, *args): return Gallery.objects.filter( slug=settings.HOME_PAGE_CAROUSEL_GALLERY_SLUG).first() def resolve_home_gallery(self, info, *args): return Gallery.objects.filter( slug=settings.HOME_PAGE_GALLERY_SLUG).first()
class Query(graphene.AbstractType): teams = DjangoConnectionField(TeamType) @login_required def resolve_teams(self, info, **kwargs): """ Retorna os times desse usuário :param info: :type info: :param kwargs: :type kwargs: :return: :rtype: """ user = info.context.user return Team.objects.filter(company__owner=user)
def connection_resolver(cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, filterset_class, filtering_args, root, info, **args): context = info.context filter_kwargs = args qs = default_manager.get_queryset() # filterset_class = args["filterset_class"] qs = filterset_class(data=filter_kwargs, queryset=qs, context=context).qs if args.get("first"): paginator = Paginator(qs, args.get("first")) page = str(int(args.get("after", "0")) + 1) qs = paginator.page(page) return DjangoConnectionField.connection_resolver( resolver, connection, qs, max_limit, enforce_first_or_last, root, info, **args)
class Query(graphene.ObjectType): rebels = graphene.Field(Faction) empire = graphene.Field(Faction) node = relay.Node.Field() ships = DjangoConnectionField(Ship, description='All the ships.') @resolve_only_args def resolve_ships(self): return get_ships() @resolve_only_args def resolve_rebels(self): return get_rebels() @resolve_only_args def resolve_empire(self): return get_empire()
class PublicationNode(DjangoObjectType): dataloader_articles = DjangoConnectionField( 'starter.types.ArticleNode', description= 'Return Article connection which contains pagination and Article information using dataloader.' ) class Meta: model = Publication interfaces = (Node, ) filterset_class = PublicationFilter connection_class = CountableConnectionBase @staticmethod def resolve_dataloader_articles(root: Publication, info: ResolveInfo, **kwargs) -> Promise: return info.context.loaders.articles_by_publication_loader.load( root.id)
class Query(graphene.ObjectType): projects = DjangoConnectionField(ProjectsType) project_detail = graphene.Field(ProjectsType, id=graphene.String()) @login_required def resolve_projects(self, info, **kwargs): """ Retorna os projetos (quadros) do usuário :param info: :type info: :param kwargs: :type kwargs: :return: :rtype: """ user = info.context.user return Project.objects.filter(company__user__id=user.id) @login_required def resolve_project_detail(self, info, id, **kwargs): """ Retorna os dados pro quadro :param id: :type id: :param info: :type info: :param kwargs: :type kwargs: :return: :rtype: """ user = info.context.user qs = Project.objects.filter(id=id, user__in=[user]) if not qs.exists(): return None return qs.first()
class SearchList(graphene.ObjectType): videos = DjangoConnectionField(Video) speakers = DjangoConnectionField(Speaker) sources = DjangoConnectionField(Source)
class Query(graphene.ObjectType): video = graphene.Field(Video, id=graphene.String(default_value=""), slug=graphene.String(default_value="")) def resolve_video(self, info, id, slug, **kwargs): try: if id: return models.Video.objects.get(id=id) return models.Video.objects.get(slug=slug) except models.Video.DoesNotExist: return None videos = DjangoFilterConnectionField(Video, filterset_class=VideoFilter) menus = graphene.List(Menu) def resolve_menus(self, info, **kwargs): return models.Menu.objects.all().order_by('priority') speaker = graphene.Field(Speaker, id=graphene.String(default_value=""), slug=graphene.String(default_value="")) def resolve_speaker(self, info, id, slug, **kwargs): try: if id: return models.Speaker.objects.get(id=id) return models.Speaker.objects.get(slug=slug) except models.Speaker.DoesNotExist: return None source = graphene.Field(Source, id=graphene.String(default_value=""), slug=graphene.String(default_value="")) def resolve_source(self, info, id, slug, **kwargs): try: if id: return models.Source.objects.get(id=id) return models.Source.objects.get(slug=slug) except models.Source.DoesNotExist: return None sponsor = graphene.Field(User, slug=graphene.String()) def resolve_sponsor(self, info, slug, **kwargs): try: return auth_models.User.objects.get(username=slug) except auth_models.User.DoesNotExist: return None creator = graphene.Field(User, slug=graphene.String()) def resolve_creator(self, info, slug, **kwargs): try: return auth_models.User.objects.get(username=slug) except auth_models.User.DoesNotExist: return None category = graphene.Field(Category, slug=graphene.String()) def resolve_category(self, info, slug, **kwargs): try: return models.Category.objects.get(slug=slug) except models.Category.DoesNotExist: return None tag = graphene.Field(Tag, slug=graphene.String()) def resolve_tag(self, info, slug, **kwargs): try: return models.Tag.objects.get(slug=slug) except models.Tag.DoesNotExist: return None playlist = graphene.Field(Playlist, slug=graphene.String()) def resolve_playlist(self, info, slug, **kwargs): try: return models.Playlist.objects.get(slug=slug) except models.Playlist.DoesNotExist: return None search_list = graphene.Field(SearchList, query=graphene.String()) def resolve_search_list(self, info, query, **kwargs): videos = models.Video.objects\ .filter( Q(title__icontains=query) |\ Q(description__icontains=query), is_published=True ).order_by('-published_at') speakers = models.Speaker.objects\ .annotate(video_amount=Count(Case(When(videospeaker__video__is_published=True, then=1))))\ .filter(Q(name__icontains=query)) sources = models.Source.objects\ .annotate(video_amount=Count(Case(When(video__is_published=True, then=1))))\ .filter(Q(name__icontains=query)) return SearchList(videos=videos, speakers=speakers, sources=sources) sources = DjangoConnectionField(Source, order_by=graphene.String(default_value=""), search=graphene.String(default_value="")) def resolve_sources(self, info, order_by, search, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return models.Source.objects\ .filter( Q(name__icontains=search) |\ Q(description__icontains=search)\ )\ .annotate(video_amount=Count(Case(When(video__is_published=True, then=1))))\ .order_by(*orders) #.filter(video_amount__gt=0)\ sponsors = DjangoConnectionField( User, order_by=graphene.String(default_value="")) def resolve_sponsors(self, info, order_by, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return auth_models.User.objects\ .filter(profile__role="SP")\ .annotate(video_amount=Count(Case(When(video_sponsor_by__is_published=True, then=1))))\ .order_by(*orders) # .filter(video_amount__gt=0)\ creators = DjangoConnectionField( User, order_by=graphene.String(default_value="")) def resolve_creators(self, info, order_by, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return auth_models.User.objects\ .filter(profile__role="PO")\ .annotate(video_amount=Count(Case(When(video_created_by__is_published=True, then=1))))\ .order_by(*orders) # .filter(video_amount__gt=0)\ speakers = DjangoConnectionField( Speaker, order_by=graphene.String(default_value=""), search=graphene.String(default_value="")) def resolve_speakers(self, info, order_by, search, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return models.Speaker.objects\ .filter( Q(name__icontains=search) |\ Q(description__icontains=search)\ )\ .annotate(video_amount=Count(Case(When(videospeaker__video__is_published=True, then=1))))\ .order_by(*orders) # categories = graphene.List(Category, order_by=graphene.String(default_value="")) categories = DjangoConnectionField( Category, order_by=graphene.String(default_value="")) def resolve_categories(self, info, order_by, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return models.Category.objects\ .annotate(video_amount=Count(Case(When(videocategory__video__is_published=True, then=1))))\ .order_by(*orders) # .filter(video_amount__gt=0)\ tags = DjangoConnectionField(Tag, order_by=graphene.String(default_value="")) def resolve_tags(self, info, order_by, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return models.Tag.objects\ .annotate(video_amount=Count(Case(When(video__is_published=True, then=1))))\ .order_by(*orders) # .filter(video_amount__gt=0)\ playlists = DjangoConnectionField( Playlist, order_by=graphene.String(default_value="")) def resolve_playlists(self, info, order_by, **kwargs): if order_by: orders = (order_by, '-video_amount') else: orders = ('-video_amount', ) return models.Playlist.objects\ .annotate(video_amount=Count(Case(When(playlistvideo__video__is_published=True, then=1))))\ .order_by(*orders)