class Query(ObjectType):
user = Node.Field(UserNode)
all_users = DjangoFilterConnectionField(UserNode)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(ReporterFilterNode)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(
ReporterType, filterset_class=ReporterFilter)
class Query(ObjectType):
context_articles = DjangoFilterConnectionField(
ArticleNode, filterset_class=ArticleContextFilter)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(ReporterFilterNode)
all_articles = DjangoFilterConnectionField(ArticleFilterNode)
reporter = Field(ReporterFilterNode)
article = Field(ArticleFilterNode)
def test_filter_explicit_filterset_orderable():
field = DjangoFilterConnectionField(ReporterNode,
filterset_class=ReporterFilter)
assert_orderable(field)
def test_filter_explicit_filterset_not_orderable():
field = DjangoFilterConnectionField(PetNode, filterset_class=PetFilter)
assert_not_orderable(field)
def test_filter_shortcut_filterset_orderable_headline():
field = DjangoFilterConnectionField(ArticleNode, order_by=['headline'])
assert_orderable(field)
def test_filter_shortcut_filterset_extra_meta():
field = DjangoFilterConnectionField(ArticleNode, extra_filter_meta={
'order_by': True
})
assert_orderable(field)
def test_filter_explicit_filterset_orderable():
field = DjangoFilterConnectionField(ArticleNode, filterset_class=ArticleFilter)
assert_orderable(field)
def test_filter_shortcut_filterset_orderable_true():
field = DjangoFilterConnectionField(ArticleNode, order_by=True)
assert_orderable(field)
class Query(ObjectType):
adult = Node.Field(AdultNode)
all_adults = DjangoFilterConnectionField(AdultNode)
class Query(ObjectType): book = relay.Node.Field(BookNode) books = DjangoFilterConnectionField(BookNode, filterset_class=BookFilter) author = relay.Node.Field(AuthorNode) authors = DjangoFilterConnectionField(AuthorNode)
class Query:
availability_levels = DjangoListField(AvailabilityLevelType)
boat_types = DjangoListField(BoatTypeType)
berth = relay.Node.Field(BerthNode)
berths = DjangoConnectionField(
BerthNode,
harbor=graphene.ID(),
pier=graphene.ID(),
min_width=graphene.Float(),
min_length=graphene.Float(),
is_available=graphene.Boolean(),
is_invoiceable=graphene.Boolean(),
description=
"If filtering by both pier and harbor and the pier does not belong to the given harbor, "
"will return an empty list of edges."
"\n\n**Requires permissions** to query `leases` field. "
"Otherwise, everything is available",
)
pier = relay.Node.Field(PierNode)
piers = DjangoFilterConnectionField(
PierNode,
min_berth_width=graphene.Float(),
min_berth_length=graphene.Float(),
for_application=graphene.ID(),
description=
"`Piers` allows to filter, among other fields, by `minBerthWidth` and `minBerthLength`.\n\n"
"This filter is recommended over the filter in `berths`, because it yields better results. "
"It will only return the `pier`s which contain `berth`s matching the filter, when the other will "
"return all the available `pier`s with an empty list of `berth`s in case there's no matches.\n\n"
"If you use both filters in the same query, you might get some empty `berth` results where both "
"queries overlap.\n\n"
"To filter the piers suitable for an application, you can use the `forApplication` argument. "
"**Requires permissions** to access applications."
"\n\nErrors:"
"\n* Filter `forApplication` with a user without enough permissions"
"\n * Filter `forApplication` combined with either dimension (width, length) filter",
)
harbor = relay.Node.Field(HarborNode)
harbor_by_servicemap_id = graphene.Field(
HarborNode, servicemap_id=graphene.String(required=True))
harbors = DjangoFilterConnectionField(HarborNode,
servicemap_ids=graphene.List(
graphene.String))
winter_storage_place = relay.Node.Field(WinterStoragePlaceNode)
winter_storage_places = DjangoConnectionField(WinterStoragePlaceNode)
winter_storage_place_type = relay.Node.Field(WinterStoragePlaceTypeNode)
winter_storage_place_types = DjangoConnectionField(
WinterStoragePlaceTypeNode)
winter_storage_section = relay.Node.Field(WinterStorageSectionNode)
winter_storage_sections = DjangoFilterConnectionField(
WinterStorageSectionNode)
winter_storage_area = relay.Node.Field(WinterStorageAreaNode)
winter_storage_areas = DjangoFilterConnectionField(WinterStorageAreaNode)
def resolve_availability_levels(self, info, **kwargs):
return AvailabilityLevel.objects.all()
def resolve_boat_types(self, info, **kwargs):
return BoatType.objects.all()
def resolve_berths(self,
info,
harbor: GlobalID = None,
pier: GlobalID = None,
min_width: Decimal = 0,
min_length: Decimal = 0,
**kwargs):
if pier and harbor:
raise VenepaikkaGraphQLError(
_("Cannot pass both pier and harbor filters"))
filters = Q()
if harbor:
filters &= Q(pier__harbor_id=from_global_id(harbor, HarborNode))
if pier:
filters &= Q(pier_id=from_global_id(pier, PierNode))
if min_width:
filters &= Q(berth_type__width__gte=min_width)
if min_length:
filters &= Q(berth_type__length__gte=min_length)
if "is_available" in kwargs:
filters &= Q(is_available=kwargs.get("is_available"))
if "is_invoiceable" in kwargs:
filters &= Q(is_invoiceable=kwargs.get("is_invoiceable"))
return info.context.berth_loader.load_many(
keys=Berth.objects.filter(filters).values_list("id", flat=True))
def resolve_piers(self, info, **kwargs):
return resolve_piers(info, **kwargs)
def resolve_harbor_by_servicemap_id(self, info, **kwargs):
return Harbor.objects.filter(
servicemap_id=kwargs.get("servicemap_id")).first()
def resolve_harbors(self, info, **kwargs):
# TODO: optimize this further
# currently, still results in too many DB queries
# although, django-graphene might introduce fixes for this
# so, check the state of this against a newer version later
servicemap_ids = kwargs.get("servicemap_ids", None)
qs = (Harbor.objects.filter(servicemap_id__in=servicemap_ids)
if servicemap_ids else Harbor.objects.all())
return qs.prefetch_related(
"translations",
Prefetch(
"piers",
queryset=Pier.objects.prefetch_related(
Prefetch("berths", queryset=Berth.objects.all())),
),
"piers__suitable_boat_types",
).select_related("availability_level", "municipality")
def resolve_winter_storage_places(self, info, **kwargs):
return WinterStoragePlace.objects.prefetch_related(
"winter_storage_section__area__translations",
"winter_storage_section__area__availability_level__translations",
"winter_storage_section__area__municipality__translations",
).select_related(
"winter_storage_section",
"winter_storage_section__area",
"winter_storage_section__area__availability_level",
"winter_storage_section__area__municipality",
)
def resolve_winter_storage_sections(self, info, **kwargs):
return WinterStorageSection.objects.prefetch_related(
"places",
"area__translations",
"area__availability_level__translations",
"area__municipality__translations",
).select_related("area", "area__availability_level",
"area__municipality")
def resolve_winter_storage_areas(self, info, **kwargs):
# TODO: optimize this further
# currently, still results in too many DB queries
# although, django-graphene might introduce fixes for this
# so, check the state of this against a newer version later
return WinterStorageArea.objects.prefetch_related(
"translations",
Prefetch(
"sections",
queryset=WinterStorageSection.objects.prefetch_related(
Prefetch("places",
queryset=WinterStoragePlace.objects.all())),
),
).select_related("availability_level", "municipality")
class WhiteCardQuery(graphene.ObjectType):
all_white_cards = DjangoFilterConnectionField(WhiteCardNode)
def test_global_id_field_implicit():
field = DjangoFilterConnectionField(ArticleNode, fields=['id'])
filterset_class = field.filterset_class
id_filter = filterset_class.base_filters['id']
assert isinstance(id_filter, GlobalIDFilter)
assert id_filter.field_class == GlobalIDFormField
class Query(ObjectType):
pets = DjangoFilterConnectionField(PetType)
def test_filter_shortcut_filterset_arguments_list():
field = DjangoFilterConnectionField(ArticleNode, fields=['pub_date', 'reporter'])
assert_arguments(field,
'pub_date',
'reporter',
)
class Query(ObjectType):
all_articles = DjangoFilterConnectionField(NewArticleFilterNode)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(ReporterType,
reverse_order=Boolean())
def test_filter_shortcut_filterset_extra_meta():
field = DjangoFilterConnectionField(
ArticleNode, extra_filter_meta={"exclude": ("headline", )})
assert "headline" not in field.filterset_class.get_fields()
class RelayQuery(graphene.ObjectType):
relay_transaction = graphene.relay.Node.Field(TransactionNode)
relay_transactions = DjangoFilterConnectionField(
TransactionNode, filterset_class=TransactionFilter)
def test_global_id_field_relation():
field = DjangoFilterConnectionField(ArticleNode, fields=["reporter"])
filterset_class = field.filterset_class
id_filter = filterset_class.base_filters["reporter"]
assert isinstance(id_filter, GlobalIDFilter)
assert id_filter.field_class == GlobalIDFormField
class Query(AbstractType):
all_locations = DjangoFilterConnectionField(LocationNode)
def test_global_id_multiple_field_implicit_reverse():
field = DjangoFilterConnectionField(ReporterNode, fields=["articles"])
filterset_class = field.filterset_class
multiple_filter = filterset_class.base_filters["articles"]
assert isinstance(multiple_filter, GlobalIDMultipleChoiceFilter)
assert multiple_filter.field_class == GlobalIDMultipleChoiceField
class AccountQuery(AbstractType):
accounts = DjangoFilterConnectionField(AccountNode)
account = relay.Node.Field(AccountNode)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(
ReporterType, filterset_class=ReporterFilter)
def resolve_all_reporters(self, info, **args):
return Reporter.objects.order_by("a_choice")
class RelayQuery(graphene.ObjectType):
relay_link = graphene.relay.Node.Field(LinkNode)
relay_links = DjangoFilterConnectionField(
LinkNode, filterset_class=LinkFilter)
def test_filter_shortcut_filterset_arguments_list():
field = DjangoFilterConnectionField(ArticleNode,
fields=["pub_date", "reporter"])
assert_arguments(field, "pub_date", "reporter")
class Query(graphene.ObjectType):
all_libraries = graphene.List(LibraryType)
camera = graphene.Field(CameraType,
id=graphene.UUID(),
make=graphene.String(),
model=graphene.String())
all_cameras = graphene.List(CameraType)
lens = graphene.Field(LensType, id=graphene.UUID(), name=graphene.String())
all_lenses = graphene.List(LensType)
all_apertures = graphene.List(graphene.Float)
all_exposures = graphene.List(graphene.String)
all_iso_speeds = graphene.List(graphene.Int)
all_focal_lengths = graphene.List(graphene.Float)
all_metering_modes = graphene.List(graphene.String)
all_drive_modes = graphene.List(graphene.String)
all_shooting_modes = graphene.List(graphene.String)
photo = graphene.Field(PhotoNode, id=graphene.UUID())
all_photos = DjangoFilterConnectionField(PhotoNode,
filterset_class=PhotoFilter)
all_location_tags = graphene.List(LocationTagType)
all_object_tags = graphene.List(ObjectTagType)
all_person_tags = graphene.List(PersonTagType)
all_color_tags = graphene.List(ColorTagType)
all_style_tags = graphene.List(StyleTagType)
def resolve_all_libraries(self, info, **kwargs):
user = info.context.user
return Library.objects.filter(users__user=user)
def resolve_camera(self, info, **kwargs):
id = kwargs.get('id')
make = kwargs.get('make')
model = kwargs.get('model')
if id is not None:
return Camera.objects.get(pk=id)
if make is not None and model is not None:
return Camera.objects.get(make=make, model=model)
return None
@login_required
def resolve_all_cameras(self, info, **kwargs):
user = info.context.user
return Camera.objects.filter(library__users__user=user)
def resolve_lens(self, info, **kwargs):
id = kwargs.get('id')
name = kwargs.get('name')
if id is not None:
return Lens.objects.get(pk=id)
if name is not None:
return Lens.objects.get(name=name)
return None
def resolve_all_lenses(self, info, **kwargs):
user = info.context.user
return Lens.objects.filter(library__users__user=user)
def resolve_all_apertures(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
aperture__isnull=True).values_list(
'aperture', flat=True).distinct().order_by('aperture')
def resolve_all_exposures(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
exposure__isnull=True).values_list(
'exposure', flat=True).distinct().order_by('exposure')
def resolve_all_iso_speeds(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
iso_speed__isnull=True).values_list(
'iso_speed', flat=True).distinct().order_by('iso_speed')
def resolve_all_focal_lengths(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
focal_length__isnull=True).values_list(
'focal_length', flat=True).distinct().order_by('focal_length')
def resolve_all_metering_modes(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
metering_mode__isnull=True).values_list(
'metering_mode',
flat=True).distinct().order_by('metering_mode')
def resolve_all_drive_modes(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
drive_mode__isnull=True).values_list(
'drive_mode', flat=True).distinct().order_by('drive_mode')
def resolve_all_shooting_modes(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user).exclude(
shooting_mode__isnull=True).values_list(
'shooting_mode',
flat=True).distinct().order_by('shooting_mode')
def resolve_photo(self, info, **kwargs):
id = kwargs.get('id')
if id is not None:
return Photo.objects.get(pk=id)
return None
@login_required
def resolve_all_photos(self, info, **kwargs):
user = info.context.user
return Photo.objects.filter(library__users__user=user)
def resolve_all_location_tags(self, info, **kwargs):
user = info.context.user
return Tag.objects.filter(library__users__user=user, type='L')
def resolve_all_object_tags(self, info, **kwargs):
user = info.context.user
return Tag.objects.filter(library__users__user=user, type='O')
def resolve_all_person_tags(self, info, **kwargs):
user = info.context.user
return Tag.objects.filter(library__users__user=user, type='P')
def resolve_all_color_tags(self, info, **kwargs):
user = info.context.user
return Tag.objects.filter(library__users__user=user, type='C')
def resolve_all_style_tags(self, info, **kwargs):
user = info.context.user
return Tag.objects.filter(library__users__user=user, type='S')
