class Query: analysis = DjangoObjectField(AnalysisType) analyses = DjangoPaginatedListObjectField( AnalysisListType, pagination=PageGraphqlPagination( page_size_query_param='pageSize' ) ) # Pillar analysis_pillar = DjangoObjectField(AnalysisPillarDetailType) analysis_pillars = DjangoPaginatedListObjectField( AnalysisPillarListType, pagination=PageGraphqlPagination( page_size_query_param='pageSize' ) ) @staticmethod def resolve_analyses(root, info, **kwargs) -> QuerySet: return get_analysis_qs(info) @staticmethod def resolve_analysis_pillars(root, info, **kwargs) -> QuerySet: return get_analysis_pillar_qs(info)
class UnifiedConnectorQueryType(graphene.ObjectType): unified_connector = DjangoObjectField(UnifiedConnectorType) unified_connectors = DjangoPaginatedListObjectField( UnifiedConnectorListType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize', )) connector_source = DjangoObjectField(ConnectorSourceType) connector_sources = DjangoPaginatedListObjectField( ConnectorSourceListType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize', )) connector_source_lead = DjangoObjectField(ConnectorSourceLeadType) connector_source_leads = DjangoPaginatedListObjectField( ConnectorSourceLeadListType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize', )) @staticmethod def resolve_unified_connectors(root, info, **kwargs) -> QuerySet: return get_unified_connector_qs(info) @staticmethod def resolve_connector_sources(root, info, **kwargs) -> QuerySet: return get_connector_source_qs(info) @staticmethod def resolve_connector_source_leads(root, info, **kwargs) -> QuerySet: return get_connector_source_lead_qs(info)
class Query: contact = DjangoObjectField(ContactType) communication = DjangoObjectField(CommunicationType) contact_list = DjangoPaginatedListObjectField( ContactListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) communication_list = DjangoPaginatedListObjectField( CommunicationListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize'))
class Query: resource = DjangoObjectField(ResourceType) resource_list = DjangoPaginatedListObjectField( ResourceListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) resource_group = DjangoObjectField(ResourceGroupType) resource_group_list = DjangoPaginatedListObjectField( ResourceGroupListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize'))
class Query: organization = DjangoObjectField(OrganizationType) organization_list = DjangoPaginatedListObjectField( OrganizationListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) organization_kind = DjangoObjectField(OrganizationKindObjectType) organization_kind_list = DjangoPaginatedListObjectField( OrganizationKindListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize'))
class Query: lead = DjangoObjectField(LeadDetailType) leads = DjangoPaginatedListObjectField( LeadListType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize', )) lead_group = DjangoObjectField(LeadGroupType) lead_groups = DjangoPaginatedListObjectField( LeadGroupListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) emm_entities = DjangoPaginatedListObjectField( EmmEntityListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) lead_emm_triggers = DjangoPaginatedListObjectField( LeadEmmTriggerListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) # TODO: Add Pagination emm_keywords = graphene.List(graphene.NonNull(EmmKeyWordType)) emm_risk_factors = graphene.List(graphene.NonNull(EmmKeyRiskFactorType)) @staticmethod def resolve_leads(root, info, **kwargs) -> QuerySet: return get_lead_qs(info) @staticmethod def resolve_lead_groups(root, info, **kwargs) -> QuerySet: return get_lead_group_qs(info) @staticmethod def resolve_emm_entities(root, info, **kwargs) -> QuerySet: return get_emm_entities_qs(info) @staticmethod def resolve_lead_emm_triggers(root, info, **kwargs) -> QuerySet: return get_lead_emm_entities_qs(info) @staticmethod def resolve_emm_keywords(root, info, **kwargs): return LeadEMMTrigger.objects.filter( lead__project=info.context.active_project).values( 'emm_keyword').annotate( total_count=models.Sum('count'), key=models.F('emm_keyword'), label=models.F('emm_keyword')).order_by('emm_keyword') @staticmethod def resolve_emm_risk_factors(root, info, **kwargs): return LeadEMMTrigger.objects.filter( ~models.Q(emm_risk_factor=''), ~models.Q(emm_risk_factor=None), lead__project=info.context.active_project, ).values('emm_risk_factor').annotate( total_count=models.Sum('count'), key=models.F('emm_risk_factor'), label=models.F('emm_risk_factor'), ).order_by('emm_risk_factor')
class Query: figure = DjangoObjectField(FigureType) figure_list = DjangoPaginatedListObjectField( FigureListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) source_preview = DjangoObjectField(SourcePreviewType) entry = DjangoObjectField(EntryType) entry_list = DjangoPaginatedListObjectField( EntryListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize'))
class Query(ObjectType): events = DjangoListObjectField(SummitEventListType, filterset_class=SummitEventFilter) presentations = DjangoListObjectField(PresentationListType, filterset_class=PresentationFilter) presentation = DjangoObjectField(PresentationNode) speakers = SpeakerModelType.ListField(filterset_class=SpeakerFilter) rsvps = RsvpModelType.ListField(filterset_class=RsvpFilter) rsvp_template = DjangoObjectField(RsvpTemplateNode) feedbacks = DjangoListObjectField(EventFeedbackListType, filterset_class=EventFeedbackFilter) categories = EventCategoryModelType.ListField(filterset_class=EventCategoryFilter) tags = DjangoListObjectField(TagListType, filterset_class=TagFilter) metrics = DjangoListObjectField(MetricListType, filterset_class=MetricFilter) summits = DjangoObjectField(SummitNode)
class Query(object): category = DjangoObjectField(CategoryNode) categories = List(CategoryNode) route = DjangoObjectField(RouteNode) routes = List(RouteNode) def resolve_categories(self, *args, **kwargs): return Category.objects.all() def resolve_routes(self, *args, **kwargs): return Route.objects.all()
class Query: user = DjangoObjectField(User) current_user = graphene.Field(User) institution = DjangoObjectField(Institution) research_group = DjangoObjectField(ResearchGroup) personal_account = DjangoObjectField(PersonalAccount) institutions = DjangoListObjectField(InstitutionList) def resolve_current_user(self, info, **kwargs): return info.context.user if info.context.user.is_authenticated( ) else None
class Query(object): all_categories = DjangoFilterPaginateListField( CategoryType, description='all categories query', pagination=LimitOffsetGraphqlPagination()) all_ingredients = DjangoFilterPaginateListField( IngredientType, description='all ingredients query', pagination=LimitOffsetGraphqlPagination()) category = DjangoObjectField(CategoryType, description='A certain category') ingredient = DjangoObjectField(IngredientType, description='A certain Ingredient')
class ClientQuery(object): clients = DjangoFilterPaginateListField( ClientType, pagination=LimitOffsetGraphqlPagination(ordering="raison_social"), ) all_clients = DjangoListObjectField(ClientListType) client = DjangoObjectField(ClientType)
class Query: entry = DjangoObjectField(EntryType) entries = DjangoPaginatedListObjectField( EntryListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) @staticmethod def resolve_entries(root, info, **kwargs) -> QuerySet: return get_entry_qs(info)
class Query: region = DjangoObjectField(RegionDetailType) regions = DjangoPaginatedListObjectField( RegionListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) @staticmethod def resolve_regions(root, info, **kwargs): return get_users_region_qs(info)
class Query: organization = DjangoObjectField(OrganizationType) organizations = DjangoPaginatedListObjectField( OrganizationListType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize')) public_organizations = DjangoPaginatedListObjectField( PublicOrganizationListObjectType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize')) organization_type = DjangoObjectField(OrganizationTypeType) organization_types = DjangoPaginatedListObjectField( OrganizationTypeListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) def resolve_organizations(root, info, **kwargs): # Filterout merged organizations return Organization.objects.filter(parent__isnull=True).all()
class Query(graphene.ObjectType): # These root queries return a single object, and require an ID param. hypatia_error = DjangoObjectField(ErrorType) problem = DjangoObjectField(ProblemType) assignment = DjangoObjectField(AssignmentType) teacher = DjangoObjectField(TeacherType) # These root queries return a list of objects, and can be filtered. hypatia_errors = DjangoFilterListField(ErrorType) problems = DjangoFilterListField(ProblemType) assignments = DjangoFilterListField(AssignmentType) teachers = DjangoFilterListField(TeacherType)
class Query: export = DjangoObjectField(UserExportType) exports = DjangoPaginatedListObjectField( UserExportListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) @staticmethod def resolve_exports(root, info, **kwargs) -> QuerySet: return get_export_qs(info).filter(is_preview=False)
class Query: review_comment = DjangoObjectField(EntryReviewCommentDetailType) review_comments = DjangoPaginatedListObjectField( EntryReviewCommentListType, pagination=NoOrderingPageGraphqlPagination( page_size_query_param='pageSize')) @staticmethod def resolve_review_comments(root, info, **kwargs): return get_entry_comment_qs(info)
class Query: me = graphene.Field(UserMeType) user = DjangoObjectField(UserType) users = DjangoPaginatedListObjectField( UserListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) @staticmethod def resolve_me(root, info, **kwargs) -> Union[User, None]: if info.context.user.is_authenticated: return info.context.user return None
class Query: assessment = DjangoObjectField(AssessmentType) assessments = DjangoPaginatedListObjectField( AssessmentListType, pagination=PageGraphqlPagination( page_size_query_param='pageSize' ) ) @staticmethod def resolve_assessments(root, info, **kwargs) -> QuerySet: return get_assessment_qs(info)
class Query(ObjectType): characterClass = DjangoObjectField(CharacterClassType) ability = DjangoObjectField(AbilityType) character = DjangoObjectField(CharacterType) abilityUse = DjangoObjectField(AbilityUseType) gameSession = DjangoObjectField(GameSessionType) learnedAbility = DjangoObjectField(LearnedAbilityType) allCharacterClasses = DjangoFilterListField(CharacterClassType) allAbilities = DjangoFilterListField(AbilityType) allAbilityUses = DjangoFilterListField(AbilityUseType) allLearnedAbilities = DjangoFilterListField(LearnedAbilityType) allAbilitiesForClasses = List(AbilityType, classes=List(Int)) usersCharacters = List(CharacterType) learnedAbilities = List(AbilityType) def resolve_allAbilitiesForClasses(root, info, classes): return abilityService.getAllAbilitiesForClasses(classes) def resolve_usersCharacters(root, info): userId = info.context.user.id return characterService.getCharactersForUser(userId) def resolve_learnedAbilities(root, info): user = info.context.user gameData = gameDataService.getOrCreateGameData(user) return abilityService.getLearnedAbilitiesForCharacter( gameData.currentCharacter)
class Query: project = DjangoObjectField(ProjectDetailType) projects = DjangoPaginatedListObjectField( ProjectListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) recent_projects = graphene.List(graphene.NonNull(ProjectDetailType)) project_explore_stats = graphene.Field(ProjectExploreStatType) # only the region for which project are public projects_by_region = DjangoPaginatedListObjectField( ProjectByRegionListType) # PUBLIC NODES public_projects = DjangoPaginatedListObjectField( PublicProjectListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) public_projects_by_region = DjangoPaginatedListObjectField( PublicProjectByRegionListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) # NOTE: This is a custom feature, see https://github.com/the-deep/graphene-django-extras # see: https://github.com/eamigo86/graphene-django-extras/compare/graphene-v2...the-deep:graphene-v2 @staticmethod def resolve_projects(root, info, **kwargs) -> QuerySet: return Project.get_for_gq(info.context.user).distinct() @staticmethod def resolve_recent_projects(root, info, **kwargs) -> QuerySet: # only the recent project of the user member of queryset = Project.get_for_gq(info.context.user, only_member=True) return Project.get_recent_active_projects(info.context.user, queryset) @staticmethod def resolve_projects_by_region(root, info, **kwargs): return Region.objects\ .filter(centroid__isnull=False)\ .order_by('centroid') @staticmethod def resolve_project_explore_stats(root, info, **kwargs): return info.context.dl.project.resolve_explore_stats() # PUBLIC RESOLVERS @staticmethod def resolve_public_projects(root, info, **kwargs) -> QuerySet: return PublicProjectListType.queryset() @staticmethod def resolve_public_projects_by_region(*args, **kwargs): return Query.resolve_projects_by_region(*args, **kwargs)
class AssistedTaggingRootQueryType(graphene.ObjectType): tagging_model = DjangoObjectField(AssistedTaggingModelType) tagging_models = graphene.List( graphene.NonNull(AssistedTaggingModelType), ) prediction_tag = DjangoObjectField(AssistedTaggingModelPredictionTagType) prediction_tags = graphene.List( graphene.NonNull(AssistedTaggingModelPredictionTagType) ) @staticmethod def resolve_tagging_models(root, info, **kwargs): return AssistedTaggingModel.objects.prefetch_related( Prefetch( 'versions', queryset=AssistedTaggingModelVersion.objects.order_by('-version'), ), ).all() @staticmethod def resolve_prediction_tags(root, info, **kwargs): return AssistedTaggingModelPredictionTag.objects.all()
class Query: trigger_list = DjangoFilterListField(TriggerType) sub_type_trigger_list = DjangoFilterListField(TriggerSubObjectType) violence_list = DjangoFilterListField(ViolenceType) actor_list = DjangoFilterListField(ActorType) disaster_category_list = DjangoFilterListField(DisasterCategoryType) disaster_sub_category_list = DjangoFilterListField(DisasterSubCategoryType) disaster_type_list = DjangoFilterListField(DisasterTypeObjectType) disaster_sub_type_list = DjangoFilterListField(DisasterSubObjectType) event = DjangoObjectField(EventType) event_list = DjangoPaginatedListObjectField( EventListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize'))
class Query: analysis_framework = DjangoObjectField(AnalysisFrameworkDetailType) analysis_frameworks = DjangoPaginatedListObjectField( AnalysisFrameworkListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) public_analysis_frameworks = DjangoPaginatedListObjectField( PublicAnalysisFrameworkListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize')) @staticmethod def resolve_analysis_frameworks(root, info, **kwargs) -> QuerySet: return AnalysisFramework.get_for_gq(info.context.user).distinct() @staticmethod def resolve_public_analysis_frameworks(root, info, **kwargs) -> QuerySet: return AnalysisFramework.objects.filter(is_private=False).distinct()
class Query(graphene.ObjectType): # Possible User list queries definitions all_users = DjangoListObjectField(UserListType, description=_('All Users query')) all_users1 = DjangoFilterPaginateListField( UserType, pagination=LimitOffsetGraphqlPagination()) all_users2 = DjangoFilterListField(UserType) all_users3 = DjangoListObjectField(UserListType, filterset_class=filtersets.UserFilter, description=_('All Users query')) # Defining a query for a single user # The DjangoObjectField have a ID type input field, that allow filter by id and is't necessary to define resolve function user = DjangoObjectField(UserType, description=_('Single User query')) # Another way to define a query to single user user1 = UserListType.RetrieveField( description=_('User List with pagination and filtering'))
class Mutation(object): analysis_framework_create = CreateAnalysisFramework.Field() analysis_framework = DjangoObjectField(AnalysisFrameworkMutationType)
class Query(object): tutorial = DjangoObjectField(TutorialNode, id=Int()) tutorials = List(TutorialNode) def resolve_tutorials(self, info, **kwargs): return Tutorial.objects.all()
class Mutation(object): project_create = CreateProject.Field() join_project = CreateProjectJoin.Field() project_join_request_delete = ProjectJoinRequestDelete.Field() project = DjangoObjectField(ProjectMutationType)
class Query: crisis = DjangoObjectField(CrisisType) crisis_list = DjangoPaginatedListObjectField( CrisisListType, pagination=PageGraphqlPagination(page_size_query_param='pageSize'))