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'))
