class UserStateQuery(ObjectType): user_states = graphene.List( R.prop('graphene_class', user_state_config), **top_level_allowed_filter_arguments(R.prop('graphene_fields', user_state_config), R.prop('graphene_class', user_state_config)) ) @login_required def resolve_user_states(self, info, **kwargs): """ Resolves only the user_state of the current user. If the user is_staff or is_superuser then the user id will not be passed implicitly to the query :param info: :param kwargs: :return: """ context = info.context user = R.prop_or(None, 'user', context) admin = user.is_staff or user.is_superuser q_expressions = process_filter_kwargs( UserState, **R.merge_all([ dict(deleted__isnull=True), kwargs, dict(user__id=user.id) if not admin else {} ]) ) return UserState.objects.filter( *q_expressions )
class LocationQuery(ObjectType): locations = graphene.List( LocationType, **top_level_allowed_filter_arguments(location_fields, LocationType) ) locations_paginated = Field( LocationPaginatedType, **pagination_allowed_filter_arguments(location_paginated_fields, LocationPaginatedType) ) @staticmethod def _resolve_locations(info, **kwargs): # Default to not deleted, it can be overridden by kwargs return query_with_filter_and_order_kwargs(Location, **R.merge(dict(deleted__isnull=True), kwargs)) @login_required def resolve_locations(self, info, **kwargs): return LocationQuery._resolve_locations(info, **kwargs) @login_required def resolve_locations_paginated(self, info, **kwargs): return resolve_paginated_for_type( LocationPaginatedType, LocationQuery._resolve_locations, **kwargs )
class JurisdictionQuery(ObjectType): jurisdictions = graphene.List( JurisdictionType, **top_level_allowed_filter_arguments(jurisdiction_fields, JurisdictionType)) jurisdictions_paginated = Field( JurisdictionPaginatedType, **pagination_allowed_filter_arguments(jurisdiction_paginated_fields, JurisdictionPaginatedType)) jurisdictions_versioned = Field( JurisdictionVersionedType, **versioning_allowed_filter_arguments(jurisdiction_versioned_fields, JurisdictionVersionedType)) @staticmethod def _resolve_jurisdictions(info, **kwargs): return jurisdiction_resolver('filter', **kwargs) def resolve_jurisdictions(self, info, **kwargs): return jurisdiction_resolver(info, **kwargs) def resolve_jurisdictions_paginated(self, info, **kwargs): return resolve_paginated_for_type( JurisdictionPaginatedType, JurisdictionQuery._resolve_jurisdictions, **kwargs) def resolve_jurisdictions_versioned(self, info, **kwargs): """ Get the version history of the jurisdiction matching the kwargs :param info: :param kwargs: id is the only thing required :return: A list of versions """ return resolve_version_instance(JurisdictionVersionedType, jurisdiction_resolver, **kwargs)
class SettingsQuery(ObjectType): settings = graphene.List( SettingsType, **top_level_allowed_filter_arguments(settings_fields, RegionType)) def resolve_settings(self, info, **kwargs): q_expressions = process_filter_kwargs( Settings, **R.merge(dict(deleted__isnull=True), kwargs)) return Settings.objects.filter(*q_expressions)
def versioning_allowed_filter_arguments(fields, graphene_type): """ TODO no longer needed. version props filter props are filtered out in schema_helpers top_level_allowed_filter_arguments for versioned types so we don't add filters to the top-level props like revisionContains. We don't (currenlty) want a filter like revisionContains :param fields: :param graphene_type: :return: """ return top_level_allowed_filter_arguments(fields, graphene_type)
class FooQuery(ObjectType): id = graphene.Int(source='pk') foos = graphene.List( FooType, **top_level_allowed_filter_arguments(foo_fields, FooType)) @login_required def resolve_foos(self, info, **kwargs): q_expressions_sets = process_filter_kwargs_with_to_manys(Foo, **kwargs) return query_sequentially(Foo.objects, 'filter', q_expressions_sets)
def pagination_allowed_filter_arguments(fields, graphene_type): """ # TODO Filtering in schema_helperws keeps page variables from being having filters, so this function isn't # really needed now top_level_allowed_filter_arguments for paginated types so we don't add filters to the top-level props like page. We don't want a filter like pageContains :param fields: :param graphene_type: :return: """ return top_level_allowed_filter_arguments(fields, graphene_type)
class SearchLocationQuery(ObjectType): search_locations = graphene.List( SearchLocationType, **top_level_allowed_filter_arguments(search_location_fields, SearchLocationType)) @staticmethod def _resolve_search_locations(info, **kwargs): # TODO for use with versioning, pagination return search_location_resolver('filter', **kwargs) def resolve_search_locations(self, info, **kwargs): return search_location_resolver('filter', **kwargs)
class ResourceQuery(ObjectType): id = graphene.Int(source='pk') resources = graphene.List( ResourceType, **top_level_allowed_filter_arguments(resource_fields, ResourceType)) @login_required def resolve_resources(self, info, **kwargs): q_expressions = process_filter_kwargs( Resource, **R.merge(dict(deleted__isnull=True), kwargs)) return Resource.objects.filter(*q_expressions)
class GroupStateQuery(ObjectType): group_states = graphene.List( R.prop('graphene_class', group_state_config), **top_level_allowed_filter_arguments(R.prop('graphene_fields', group_state_config), R.prop('graphene_class', group_state_config)) ) @login_required def resolve_group_states(self, info, **kwargs): q_expressions = process_filter_kwargs(GroupState, **R.merge(dict(deleted__isnull=True), kwargs)) return R.prop('model_class', group_state_config).objects.filter( *q_expressions )
class SearchJurisdictionQuery(ObjectType): jurisdictions = graphene.List( SearchJurisdictionType, **top_level_allowed_filter_arguments( raw_search_jurisdiction_fields(fields_with_filter_fields), SearchJurisdictionType, # fields_with_filter_fields puts filters on inner props. We don't want filters top-level with_filter_fields=False)) @staticmethod def _resolve_search_jurisdictions(info, **kwargs): return search_jurisdiction_resolver('filter', **kwargs) def resolve_search_jurisdictions(self, info, **kwargs): return search_jurisdiction_resolver(info, **kwargs)
class RegionQuery(ObjectType): regions = graphene.List( RegionType, **top_level_allowed_filter_arguments(region_fields, RegionType)) regions_paginated = Field( RegionPaginatedType, **pagination_allowed_filter_arguments(region_paginated_fields, RegionPaginatedType)) @staticmethod def _resolve_regions(info, **kwargs): return region_resolver('filter', **kwargs) @login_required def resolve_regions(self, info, **kwargs): return RegionQuery._resolve_regions(info, **kwargs) @login_required def resolve_regions_paginated(self, info, **kwargs): return resolve_paginated_for_type(RegionPaginatedType, RegionQuery._resolve_regions, **kwargs)