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)