class Query(graphene.ObjectType):
quiz = graphene.String()
all_quizzes = DjangoListField(QuizzesType)
single_quiz = graphene.Field(QuizzesType, id=graphene.Int())
all_questions = DjangoListField(QuestionType)
single_question = graphene.Field(QuestionType, id=graphene.Int())
all_answers_for_question = graphene.List(AnswerType, id=graphene.Int())
def resolve_quiz(root, info):
return f'This is the first question'
def resolve_all_quizzes(root, info):
return Quizzes.objects.all()
# return Quizzes.objects.filter(id=1)
def resolve_single_quiz(root, info, id):
return Quizzes.objects.get(pk=id)
def resolve_all_questions(root, info):
return Question.objects.all()
def resolve_single_question(root, info, id):
return Question.objects.all(pk=id)
def resolve_all_answers_for_question(root, info, id):
return Answer.objects.filter(question=id)
class Query(graphene.ObjectType):
categories = DjangoListField(CategoryType)
subcategories = graphene.List(SubCategoryType)
all_categories = graphene.List(CategoryType)
category_by_name = graphene.Field(CategoryType,
name=graphene.String(required=True))
items = DjangoListField(ProductType, name=graphene.String(required=False))
def resolve_subcategories(root, info):
# We can easily optimize query count in the resolve method
return SubCategory.objects.select_related("category").all()
def resolve_all_categories(root, info, **kwargs):
qs = Category.objects.all()
return qs
def resolve_category_by_name(root, info, name):
try:
return Category.objects.get(name=name)
except Category.DoesNotExist:
return None
def resolve_items(root, info, **kwargs):
name = kwargs.get('name', '')
qs = Product.objects.all()
if name:
qs = qs.filter(name__icontains=name)
return qs
class Query(graphene.ObjectType):
users = DjangoListField(UserType)
places = DjangoListField(PlaceType)
topics = DjangoListField(TopicType)
events = DjangoListField(EventType)
test = graphene.String()
get_user = graphene.Field(UserType, ip=graphene.String(), id=graphene.ID())
def resolve_get_user(self,
info: ResolveInfo,
ip: Optional[str] = None,
id: Optional[str] = None):
if ip:
user, _ = User.objects.get_or_create(ip=ip)
return user
elif id:
return User.objects.get(id=id)
return None
def resolve_test(self, info: ResolveInfo) -> str:
return "API works"
debug = graphene.Field(DjangoDebug, name='_debug')
class Query(graphene.ObjectType):
all_subjects = graphene.List(SubjectType)
all_papers = DjangoListField(PaperType)
questions_by_paper = DjangoListField(QuestionType,
paper=graphene.Int(required=True))
choices_by_question = DjangoListField(ChoiceType,
question=graphene.Int(required=True))
def resolve_all_subjects(root, info):
return models.Subject.objects.all()
def resolve_all_papers(root, info):
return models.Paper.objects.all()
def resolve_questions_by_paper(root, info, paper):
try:
return models.Question.objects.filter(paper=paper)
except models.Question.DoesNotExist:
return None
def resolve_choices_by_question(root, info, question):
try:
return models.Choice.objects.filter(question=question)
except models.Choice.DoesNotExist:
return None
class Query(UserQuery, MeQuery, ObjectType):
categories = DjangoListField(CategoryType)
articles = DjangoListField(ArticleType)
article = graphene.Field(ArticleType, id=graphene.String())
users = DjangoListField(UserType)
def resolve_article(self, info, id):
return Article.objects.get(pk=id)
class Query(graphene.ObjectType):
configurations = DjangoListField(ConfigurationType)
consumer_models = DjangoListField(ConsumerModelType)
producer_models = DjangoListField(ProducerModelType)
users = DjangoListField(UserType)
message_filters = DjangoListField(MessageFilterModelType)
if settings.DEBUG:
debug = graphene.Field(DjangoDebug)
class Query(graphene.ObjectType):
student = graphene.Field(StudentType, id=graphene.Int())
tutor = graphene.Field(TutorType, id=graphene.Int())
all_students = DjangoListField(StudentType)
all_tutors = DjangoListField(TutorType)
def resolve_student(root, info, id):
return get_object_or_404(Student, pk=id)
def resolve_tutor(root, info, id):
return get_object_or_404(Tutor, pk=id)
class NotasQueries(graphene.ObjectType):
componentes = DjangoListField(ComponenteType)
# notas_alumno = DjangoFilterConnectionField(NotaAlumnoType, )
notas_alumnos = DjangoListField(NotaAlumnoType)
notas_alumno = DjangoListField(NotaAlumnoType,
id_alumo=graphene.ID(required=True))
def resolve_notas_alumno(self, info, id_alumo):
return NotaAlumno.objects \
.filter(alumno_aula__id=id_alumo, auth_estado=BaseModel.ACTIVO) \
.order_by('componente__nombre')
def resolve_notas_alumnos(self, info):
return NotaAlumno.objects.filter(auth_estado=BaseModel.ACTIVO)
class Query(object):
bootcamps = DjangoListField(BootcampType)
cohorts = DjangoListField(CohortType)
instructors = DjangoListField(InstructorType)
topics = DjangoListField(TopicType)
instructor = Field(InstructorType, id=Int(), name=String())
def resolve_date(self, info):
return datetime.now().date()
def resolve_instructor(self, info, id=None, name=None):
if id is not None:
return Instructor.objects.get(pk=id)
if name is not None:
return Instructor.objects.get(name=name)
return None
class UserGroupType(DjangoObjectType):
class Meta:
model = UserGroup
only_fields = (
'id',
'title',
'description',
'created_at',
'created_by',
'modified_at',
'modified_by',
'client_id',
'custom_project_fields',
'global_crisis_monitoring',
)
current_user_role = graphene.Field(GroupMembershipRoleEnum)
current_user_role_display = EnumDescription(
source='get_current_user_role_display')
memberships_count = graphene.Int(required=True)
memberships = DjangoListField(GroupMembershipType)
@staticmethod
def resolve_current_user_role(root, info):
return info.context.dl.user_group.current_user_role.load(root.id)
@staticmethod
def resolve_memberships(root, info):
# Only for groups with current user as members are fetched. (Logic in dataloader)
return info.context.dl.user_group.memberships.load(root.id)
@staticmethod
def resolve_memberships_count(root, info):
return info.context.dl.user_group.memberships_count.load(root.id)
class CommentPagination(ObjectType):
id = graphene.Int()
pageNum = graphene.Int()
pageSize = graphene.Int()
totalPages = graphene.Int()
totalCount = graphene.Int()
comments = DjangoListField(Comment)
class UserPagination(ObjectType):
id = graphene.Int()
pageNum = graphene.Int()
pageSize = graphene.Int()
totalPages = graphene.Int()
totalCount = graphene.Int()
users = DjangoListField(User)
class PostPagination(ObjectType):
id = graphene.Int()
pageNum = graphene.Int()
pageSize = graphene.Int()
totalPages = graphene.Int()
totalCount = graphene.Int()
posts = DjangoListField(Post)
class ProcessPagination(ObjectType):
id = graphene.Int()
pageNum = graphene.Int()
pageSize = graphene.Int()
totalPages = graphene.Int()
totalCount = graphene.Int()
processes = DjangoListField(Process)
class TutorType(UserType):
courses = DjangoListField(CourseType)
class Meta:
model = Tutor
fields = ('id', 'first_name', 'last_name', 'email', 'birthdate',
'gender', 'image', 'resume')
class ArticleType(DjangoObjectType):
user = UserType
likes = DjangoListField(LikeType)
class Meta:
model = Article
fields = ('id', 'slug', 'title', 'content', 'user', 'likes',
'categories', 'created_on', 'updated_on')
class GraphType(PublishedFilterBase, DjangoObjectType):
priority = graphene.Field(GraphPriorityType, required=True)
authors = DjangoListField(UserType)
categories = DjangoListField(CategoryType)
content = graphene.Field(GraphContentInterface,
translation=graphene.String(),
default=graphene.String(),
required=True)
# Don't worried about tutorials and execresultjson_set since
# they are convered under ManyToOneRel/ManyToManyRel/ManyToManyField
# and will be automatically translated to DjangoListField
@graphene.resolve_only_args
def resolve_priority(self):
return GraphPriorityType(priority=self.priority,
label=GraphPriority(self.priority).label)
@graphene.resolve_only_args
def resolve_authors(self):
return self.authors.all()
@show_published_only
@graphene.resolve_only_args
def resolve_categories(self, is_published_only: bool):
raw_results = self.categories.is_published_only_all(
is_published_only=is_published_only)
return raw_results
@show_published_only
@graphene.resolve_only_args
def resolve_content(self,
is_published_only: bool,
translation: str = 'en-us',
default: str = ''):
return self.get_translation(translation, default, is_published_only)
@field_adder(time_date_mixin_field, published_mixin_field,
uuid_mixin_field)
class Meta:
model = Graph
fields = ('url', 'name', 'cyjs', 'categories', 'tutorials',
'execresultjson_set', 'priority')
description = 'Graph type that contains info of a graph like ' \
'cyjs, style json, and layout json'
class UsersAppQueries(graphene.ObjectType):
"""
GraphQL queries for users app
:author: @leonard_lib
:date: 2020-09-01
"""
all_users = DjangoListField(UserType)
user_by_id = graphene.Field(
UserType,
id=graphene.ID(required=True)
)
user_by_email = graphene.Field(
UserType,
email=graphene.String(required=True)
)
@login_required
def resolve_all_users(self, info):
"""
Get all users
:author: @leonard_lib
:date: 2020-09-01
:param info:
:return List of User:
"""
print(info.context.user)
return User.objects.all()
@login_required
def resolve_user_by_id(self, info, id):
"""
Get player by ID
:author: @leonard_lib
:date: 2020-09-01
:param info:
:param id:
:return:
"""
try:
return User.objects.get(pk=id)
except User.DoesNotExist:
return None
@login_required
def resolve_user_by_email(self, info, email):
"""
Get player by email
:author: @leonard_lib
:date: 2020-09-01
:param info:
:param email:
:return:
"""
try:
return User.objects.get(email=email)
except User.DoesNotExist:
return None
class AuthorType(DjangoObjectType):
class Meta:
model = Author
fields = ("id", "name", "biodata")
posts = DjangoListField(PostType)
def resolve_posts(self, info):
return Post.objects.filter(author=self.id)
class Query(graphene.ObjectType):
# List
categories = DjangoListField(CategoryType)
quizzes = DjangoListField(QuizType)
questions = DjangoListField(QuestionType)
options = DjangoListField(OptionType)
question_options = graphene.List(OptionType, id=graphene.Int())
# Single Objects
quiz = graphene.Field(QuizType, id=graphene.Int())
question = graphene.Field(QuestionType, id=graphene.Int())
option = graphene.Field(OptionType, id=graphene.Int())
@staticmethod
def resolve_categories(root, info):
return Category.objects.all()
@staticmethod
def resolve_quizzes(root, info):
return Quiz.objects.all()
@staticmethod
def resolve_quiz(root, info, id):
return Quiz.objects.get(pk=id)
@staticmethod
def resolve_questions(root, info):
return Question.objects.all()
@staticmethod
def resolve_question(root, info, id):
return Question.objects.get(pk=id)
@staticmethod
def resolve_options(root, info):
return Option.objects.all()
@staticmethod
def resolve_question_options(root, info, id):
return Option.objects.filter(question_id=id)
@staticmethod
def resolve_option(root, info, id):
return Option.objects.get(pk=id)
class CommentType(DjangoObjectType):
class Meta:
model = Comment
fields = ("id","post", "name", "email","body","created_on","active")
posts = DjangoListField(PostType)
def resolve_posts(self, info):
return Post.objects.filter(author=self.id)
class BookQuery(ObjectType):
book = Field(BookType, id=Int(), title=String())
all_books = DjangoListField(BookType)
def resolve_book(self, info, **kwargs):
if _id := kwargs.get("id") is not None:
return Book.objects.get(pk=_id)
if title := kwargs.get("title") is not None:
return Book.objects.get(title=title)
class FilterType(DjangoObjectType):
events = DjangoListField(EventType)
class Meta:
model = EventFilter
fields = '__all__'
def resolve_events(self, *args, **kw):
return []
class TutorialType(PublishedFilterBase, DjangoObjectType):
content = graphene.Field(TutorialInterface,
translation=graphene.String(),
default=graphene.String())
categories = DjangoListField(CategoryType, required=True)
rank = graphene.Field(RankType, required=True)
@show_published_only
@graphene.resolve_only_args
def resolve_categories(self, is_published_only: bool):
raw_results = self.categories.is_published_only_all(
is_published_only=is_published_only)
return raw_results
@show_published_only
@graphene.resolve_only_args
def resolve_content(self,
is_published_only: bool,
translation: str = 'en-us',
default: str = ''):
return self.get_translation(translation, default, is_published_only)
@show_published_only
@graphene.resolve_only_args
def resolve_code(self, is_published_only: bool):
# TODO write a custom manager for this
code = getattr(self, 'code', None)
if code and (code.is_published or not is_published_only):
return code
return Code(id=FAKE_UUID, code='# Empty \n', tutorial=Tutorial())
@graphene.resolve_only_args
def resolve_rank(self):
return RankType(level=self.level, section=self.section)
@field_adder(time_date_mixin_field, published_mixin_field,
uuid_mixin_field)
class Meta:
model = Tutorial
fields = (
'url',
'name',
'content',
'categories',
'graph_set',
'code',
)
description = 'The tutorial anchor for an tutorial article. ' \
'The contents are in translation table that ' \
'corresponds to certain language you want to ' \
'query. This type only contains meta info' \
'like id, url, category, associated graphs' \
'associated codes etc.'
class IngredientsQuery(graphene.ObjectType):
all_category = DjangoListField(CategoryType)
category = relay.Node.Field(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
ingredient = relay.Node.Field(IngredientNode)
all_ingredients = DjangoFilterConnectionField(IngredientNode)
# schema = graphene.Schema(query=IngredientsQuery)
class Query(graphene.ObjectType):
all_questions = graphene.Field(QuestionType, id=graphene.Int())
all_answers = graphene.List(AnswerType, id=graphene.Int())
all_quizzes = DjangoListField(QuizzesType)
def resolve_all_questions(root, info, id):
return Question.objects.get(pk=id)
def resolve_all_answers(root, info, id):
return Answer.objects.filter(question=id)
def resolve_all_quizzes(root, info):
return Quizzes.objects.all()
class Query(graphene.ObjectType):
all_users = DjangoListField(UserSchema)
user = graphene.Field(UserSchema, user_id=graphene.ID(required=True))
user_profile = graphene.Field(UserProfileSchema, user_id=graphene.ID(required=True))
def resolve_all_users(self, info):
return MyUser.objects.all()
def resolve_user(self, info, user_id):
return MyUser.objects.get(id=user_id)
def resolve_user_profile(self, info, user_id):
return MyUserProfile.objects.prefetch_related('myuser').get(id=user_id)
class TutorialInterface(graphene.Interface):
id = graphene.UUID()
title = graphene.String()
authors = DjangoListField(UserType)
abstract = graphene.String()
content_md = graphene.String()
content_html = graphene.String()
is_published = graphene.Boolean()
created_time = graphene.DateTime()
modified_time = graphene.DateTime()
@graphene.resolve_only_args
def resolve_authors(self):
return self.authors.all()
class DepartmentQueries(graphene.ObjectType):
departments = DjangoListField(DepartmentType)
department = graphene.Field(DepartmentType,
id=graphene.ID(required=False),
name=graphene.String(required=False))
def resolve_department(self, info, id=None, name=None):
if id is not None and name is not None:
return Department.objects.get(id=id, name=name)
if id is not None:
return Department.objects.get(id=id)
if name is not None:
return Department.objects.get(name=name)
return None
class SectionType(ClientIdMixin, DjangoObjectType):
widgets = DjangoListField(WidgetType)
class Meta:
model = Section
only_fields = (
'id',
'title',
'order',
'tooltip',
)
@staticmethod
def resolve_widgets(root, info):
return info.context.dl.analysis_framework.sections_widgets.load(
root.id)