def connection_resolver(cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, root, info, **args): first = args.get("first") last = args.get("last") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly paginate the `{}` connection." ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the `first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the `last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver(cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, root, args, context, info): first = args.get('first') last = args.get('last') if enforce_first_or_last: assert first or last, ( 'You must provide a `first` or `last` value to properly paginate the `{}` connection.' ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `first` limit of {} records.' ).format(first, info.field_name, max_limit) args['first'] = min(first, max_limit) if last: assert last <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `last` limit of {} records.' ).format(first, info.field_name, max_limit) args['last'] = min(last, max_limit) iterable = resolver(root, args, context, info) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver( cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, filterset_class, filters_name, root, info, **args, ): # Disable `enforce_first_or_last` if not querying for `edges`. values = [ field.name.value for field in info.field_asts[0].selection_set.selections ] if "edges" not in values: enforce_first_or_last = False first = args.get("first") last = args.get("last") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly " "paginate the `{}` connection.").format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records.").format( first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records.").format( last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) filter_input = args.get(filters_name) if filter_input and filterset_class: iterable = filterset_class(data=dict(filter_input), queryset=iterable, request=info.context).qs if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver(cls, resolver, connection, default_search, max_limit, enforce_first_or_last, root, info, **args): first = args.get('first') last = args.get('last') if enforce_first_or_last: assert first or last, ( 'You must provide a `first` or `last` value to properly paginate the `{}` connection.' ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `first` limit of {} records.' ).format(first, info.field_name, max_limit) args['first'] = min(first, max_limit) if last: assert last <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `last` limit of {} records.' ).format(first, info.field_name, max_limit) args['last'] = min(last, max_limit) results = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection, default_search, args) if Promise.is_thenable(results): return Promise.resolve(results).then(on_resolve) return on_resolve(results)
def connection_resolver( cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, filterset_class, filters_name, root, info, **args, ): # Disable `enforce_first_or_last` if not querying for `edges`. values = [ field.name.value for field in info.field_asts[0].selection_set.selections ] if "edges" not in values: enforce_first_or_last = False first = args.get("first") last = args.get("last") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly " "paginate the `{}` connection." ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) filter_input = args.get(filters_name) if filter_input and filterset_class: iterable = filterset_class( data=dict(filter_input), queryset=iterable, request=info.context ).qs if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver(cls, resolver, connection_type, root, info, **args): iterable = resolver(root, info, **args) if isinstance(connection_type, graphene.NonNull): connection_type = connection_type.of_type on_resolve = partial(cls.resolve_connection, connection_type, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver( cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, root, info, **args ): first = args.get("first") last = args.get("last") offset = args.get("offset") before = args.get("before") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly paginate the `{}` connection." ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the `first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the `last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) if offset is not None: assert before is None, ( "You can't provide a `before` value at the same time as an `offset` value to properly paginate the `{}` connection." ).format(info.field_name) # eventually leads to DjangoObjectType's get_queryset (accepts queryset) # or a resolve_foo (does not accept queryset) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) on_resolve = partial( cls.resolve_connection, connection, args, max_limit=max_limit ) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def resolver(self, parent_resolver, root, info, *args, **kwargs): routing_key = None if self._classifier: routing_key = self._classifier(root, info, *args, **kwargs) if Promise.is_thenable(routing_key): return Promise.resolve( routing_key).then(lambda key: self._resolver( key, parent_resolver, root, info, *args, **kwargs)) return self._resolver(routing_key, parent_resolver, root, info, *args, **kwargs)
def relay_connection_resolver( cls, resolver, connection, max_limit, enforce_first_or_last, root, info, **args ): # eventually leads to DjangoObjectType's get_queryset (accepts queryset) # or a resolve_foo (does not accept queryset) iterable = resolver(root, info, **args) on_resolve = partial( cls.resolve_connection, connection, args, max_limit=max_limit ) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver(cls, resolver, connection_type, root, info, connection_field=None, **args): first = args.get("first") last = args.get("last") enforce_first_or_last = args.get("enforce_first_or_last") max_limit = args.get("max_limit") # connection_field = args.get("connection_field") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly " "paginate the `{}` connection.").format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds " "the `first` limit of {} records.").format( first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds " "the `last` limit of {} records.").format( last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) if isinstance(connection_type, graphene.NonNull): connection_type = connection_type.of_type on_resolve = partial(cls.resolve_connection, connection_type, args, connection_field=connection_field) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver( cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, csd_filter_fields, root, info, **args, ): cls.validate_first_last_limit(args, enforce_first_or_last, max_limit, info) # eventually leads to DjangoObjectType's get_queryset (accepts queryset) # or a resolve_foo (does not accept queryset) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) filter_dict = args.get('filter', {}) if filter_dict: normalized_filter_dict = convert_dict_camel_to_underscore( filter_dict) iterable = get_filtered_queryset(normalized_filter_dict, iterable, csd_filter_fields) # apply ordering order_list = args.get('orderBy', []) if order_list: order_list = [camel_to_underscore(order) for order in order_list] iterable = iterable.order_by(*order_list) on_resolve = partial(cls.resolve_connection, connection, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def _resolver(self, routing_key, parent_resolver, root, info, *args, **kwargs): handler = None if routing_key: handler = self._get_handler(root, info, *args, routing_key=routing_key, **kwargs) if not handler: handler = self._default_handler or parent_resolver if handler: if Promise.is_thenable(handler): return Promise.resolve(handler(root, info, *args, **kwargs)) return handler(root, info, *args, **kwargs) return None
def connection_resolver( cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, filterset_class, filters_name, root, info, **args, ): # Disable `enforce_first_or_last` if not querying for `edges`. values = [ field.name.value for field in info.field_asts[0].selection_set.selections ] if "edges" not in values: enforce_first_or_last = False first = args.get("first") last = args.get("last") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly " "paginate the `{}` connection." ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) on_resolve = partial(cls.resolve_connection, connection, args) filter_input = args.get(filters_name) if filter_input and filterset_class: instance = filterset_class( data=dict(filter_input), queryset=iterable, request=info.context ) # Make sure filter input has valid values if not instance.is_valid(): raise GraphQLError(json.dumps(instance.errors.get_json_data())) iterable = instance.qs if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver( cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, filterset_class, filters_name, root, info, **args, ): # Disable `enforce_first_or_last` if not querying for `edges`. values = [ field.name.value for field in info.field_asts[0].selection_set.selections ] if "edges" not in values: enforce_first_or_last = False first = args.get("first") last = args.get("last") if enforce_first_or_last and not (first or last): raise GraphQLError( f"You must provide a `first` or `last` value to properly paginate " f"the `{info.field_name}` connection.") if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records.").format( first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records.").format( last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) on_resolve = partial(cls.resolve_connection, connection, args, max_limit=max_limit) iterable = cls.filter_iterable(iterable, filterset_class, filters_name, info, **args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver( cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, filterset_class, filters_name, root, info, **args, ): enforce_first_or_last = cls.is_first_or_last_required(info) first = args.get("first") last = args.get("last") if enforce_first_or_last and not (first or last): raise GraphQLError( f"You must provide a `first` or `last` value to properly paginate " f"the `{info.field_name}` connection.") if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records.").format( first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records.").format( last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) on_resolve = partial(cls.resolve_connection, connection, args, max_limit=max_limit) # for nested filters get channel from ChannelContext object if "channel" not in args and hasattr(root, "channel_slug"): args["channel"] = root.channel_slug iterable = cls.filter_iterable(iterable, filterset_class, filters_name, info, **args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def connection_resolver(cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, root, info, **args): first = args.get("first") last = args.get("last") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly paginate the `{}` connection." ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the `first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the `last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) # eventually leads to DjangoObjectType's get_queryset (accepts queryset) # or a resolve_foo (does not accept queryset) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) club = args.get('club', None) customized_club_filters = [ 'all_amendments', 'all_interpellations', 'all_debate_appearances' ] current_resolver = resolver.args[0] if club and current_resolver in customized_club_filters: id_tuple = from_global_id(club) if id_tuple[0] == 'ClubType': dfilter_key = 'date' if current_resolver == 'all_amendments': filter_key = 'submitters' elif current_resolver == 'all_interpellations': filter_key = 'asked_by' elif current_resolver == 'all_debate_appearances': filter_key = 'debater' dfilter_key = 'start' iterable = iterable.filter( Q( **{ '{}__club_memberships__club__id'.format(filter_key): id_tuple[1] }) & Q( **{ '{}__club_memberships__start__lte'.format(filter_key): F(dfilter_key) }) & (Q( **{ '{}__club_memberships__end__gte'.format(filter_key): F(dfilter_key) } ) | Q( **{ '{}__club_memberships__end__isnull'.format(filter_key): True }))).distinct() order = args.get('orderBy', None) if order: iterable = iterable.order_by(*order) on_resolve = partial(cls.resolve_connection, connection, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def _resolver(root, info, *args, **kwargs): if self._acl_validator(root, info, *args, **kwargs): result = resolver(root, info, *args, **kwargs) if Promise.is_thenable(result): return Promise.resolve(result) return result
def connection_resolver( cls, resolver, connection, default_manager, queryset_resolver, max_limit, enforce_first_or_last, filterset_class, filters_name, sort_enum, root, info, **args, ): sort_by = args.get("sort_by") # Disable `enforce_first_or_last` if not querying for `edges`. values = [field.name.value for field in info.field_asts[0].selection_set.selections] if "edges" not in values: enforce_first_or_last = False first = args.get("first") last = args.get("last") if enforce_first_or_last and not (first or last): raise GraphQLError( f"You must provide a `first` or `last` value to properly paginate " f"the `{info.field_name}` connection." ) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) if iterable is None: iterable = default_manager # gql_optimizer query iterable = gql_optimizer.query(iterable, info) if sort_by: try: custom_sort_by = getattr(sort_enum, f"qs_with_{sort_by['field']}", None) if custom_sort_by: iterable = custom_sort_by(iterable) iterable = iterable.order_by(f"{sort_by['direction']}{sort_by['field']}") except FieldError: raise GraphQLError("Received sorter is invalid.") # thus the iterable gets refiltered by resolve_queryset # but iterable might be promise iterable = queryset_resolver(connection, iterable, info, args) on_resolve = partial(cls.resolve_connection, connection, args) filter_input = args.get(filters_name) if filter_input and filterset_class: instance = filterset_class( data=dict(filter_input), queryset=iterable, request=info.context ) # Make sure filter input has valid values if not instance.is_valid(): raise GraphQLError(json.dumps(instance.errors.get_json_data())) iterable = instance.qs if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)