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)
