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)
