def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): if self.fetch_fn is not None: qs = self.fetch_fn(info.context) elif self.property_name is not None and root and is_valid_django_model( root._meta.model): qs = getattr(root, self.property_name) else: qs = queryset_factory(manager, info.field_asts, info.fragments, **kwargs) filter_kwargs = { k: v for k, v in kwargs.items() if k in filtering_args } qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) count = qs.count() results = maybe_queryset(qs) return DjangoListObjectBase( count=count, results=results, results_field_name=self.type._meta.results_field_name, )
def list_resolver(self, resolver, manager, filterset_class, filtering_args, root, info, **kwargs): qs_resolve_override = True qs = maybe_queryset(resolver(root, info, **kwargs)) if qs is None: qs = self.get_queryset(manager) qs_resolve_override = False if not self.skip_filters: filter_kwargs = { k: v for k, v in kwargs.items() if k in filtering_args } qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs if not qs_resolve_override and root and is_valid_django_model( root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) if getattr(self, "pagination", None): qs = self.pagination.paginate_queryset(qs, **kwargs) if not qs_resolve_override: qs = self.refactor_query(qs, info, fragments=info.fragments, **kwargs) return maybe_queryset(qs)
def get_obj(app_label, model_name, object_id): """ Function used by my to get objst :param app_label: A valid Django Model or a string with format: <app_label>.<model_name> :param model_name: Key into kwargs that contains de data: new_person :param object_id: :return: instance """ try: model = apps.get_model('{}.{}'.format(app_label, model_name)) assert is_valid_django_model(model), ( 'Model {}.{} do not exist.').format(app_label, model_name) obj = get_Object_or_None(model, pk=object_id) return obj except model.DoesNotExist: return None except LookupError as e: pass except ValidationError as e: raise ValidationError(e.__str__()) except TypeError as e: raise TypeError(e.__str__()) except Exception as e: raise Exception(e.__str__())
def create_obj(django_model, new_obj_key=None, *args, **kwargs): """ Function used by my on traditional Mutations to create objs :param django_model: A valid Django Model or a string with format: <app_label>.<model_name> :param new_obj_key: Key into kwargs that contains de data: new_person :param args: :param kwargs: Dict with model attributes values :return: instance of model after saved it """ try: if isinstance(django_model, six.string_types): django_model = apps.get_model(django_model) assert is_valid_django_model(django_model), ( 'You need to pass a valid Django Model or a string with format: ' '<app_label>.<model_name> to "create_obj"' ' function, received "{}".').format(django_model) data = kwargs.get(new_obj_key, None) if new_obj_key else kwargs new_obj = django_model(**data) new_obj.full_clean() new_obj.save() return new_obj except LookupError as e: pass except ValidationError as e: raise ValidationError(e.__str__()) except TypeError as e: raise TypeError(e.__str__()) except Exception as e: return e.__str__()
def list_resolver(manager, filterset_class, filtering_args, root, info, **kwargs): qs = None available_related_fields = get_related_fields(root._meta.model) field = find_field(info.field_asts[0], available_related_fields) filter_kwargs = { k: v for k, v in kwargs.items() if k in filtering_args } if field: try: if filter_kwargs: qs = operator.attrgetter('{}.filter'.format( getattr(field, 'related_name', None) or field.name))(root)(**filter_kwargs) else: qs = operator.attrgetter('{}.all'.format( getattr(field, 'related_name', None) or field.name))(root)() except AttributeError: qs = None if qs is None: qs = queryset_factory(manager, info.field_asts, info.fragments, **kwargs) qs = filterset_class(data=filter_kwargs, queryset=qs).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) return maybe_queryset(qs)
def get_obj(app_label, model_name, object_id): """ Function used to get a object :param app_label: A valid Django Model or a string with format: <app_label>.<model_name> :param model_name: Key into kwargs that contains de data: new_person :param object_id: :return: instance """ try: model = apps.get_model('{}.{}'.format(app_label, model_name)) assert is_valid_django_model(model), ( 'Model {}.{} do not exist.').format(app_label, model_name) obj = get_Object_or_None(model, pk=object_id) return obj except model.DoesNotExist: return None except LookupError as e: pass except ValidationError as e: raise ValidationError(e.__str__()) except TypeError as e: raise TypeError(e.__str__()) except Exception as e: raise Exception(e.__str__())
def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=False, only_fields=(), exclude_fields=(), filter_fields=None, interfaces=(), **options): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not registry: registry = get_global_registry() assert isinstance(registry, Registry), ( 'The attribute registry in {} needs to be an instance of ' 'Registry, received "{}".' ).format(cls.__name__, registry) if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception("Can only set filter_fields if Django-Filter is installed") django_fields = yank_fields_from_attrs( construct_fields(model, registry, only_fields, exclude_fields), _as=Field, ) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.registry = registry _meta.filter_fields = filter_fields _meta.fields = django_fields super(DjangoObjectType, cls).__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options) if not skip_registry: registry.register(cls)
def create_obj(model, new_obj_key=None, *args, **kwargs): """ Function used by my on traditional Mutations to create objs :param model: A valid Django Model or a string with format: <app_label>.<model_name> :param new_obj_key: Key into kwargs that contains de data: new_person :param args: :param kwargs: Dict with model attributes values :return: instance of model after saved it """ try: if isinstance(model, six.string_types): model = apps.get_model(model) assert is_valid_django_model(model), ( 'You need to pass a valid Django Model or a string with format: ' '<app_label>.<model_name> to "create_obj"' ' function, received "{}".').format(model) data = kwargs.get(new_obj_key, None) if new_obj_key else kwargs new_obj = model(**data) new_obj.full_clean() new_obj.save() return new_obj except LookupError as e: pass except ValidationError as e: raise ValidationError(e.__str__()) except TypeError as e: raise TypeError(e.__str__()) except Exception as e: return e.__str__()
def __init_subclass_with_meta__(cls, model=None, container=None, registry=None, skip_registry=False, connection=None, use_connection=None, only_fields=(), exclude_fields=(), filter_fields=None, input_for="create", nested_fields=(), **options): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not registry: registry = get_global_registry() assert isinstance(registry, Registry), ( 'The attribute registry in {} needs to be an instance of ' 'Registry, received "{}".').format(cls.__name__, registry) assert input_for.lower not in ('create', 'delete', 'update'), ( 'You need to pass a valid input_for value in {}.Meta, received "{}".' ).format(cls.__name__, input_for) input_for = input_for.lower() if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception( "Can only set filter_fields if Django-Filter is installed") django_input_fields = yank_fields_from_attrs(construct_fields( model, registry, only_fields, exclude_fields, input_for, nested_fields), _as=InputField, sort=False) _meta = DjangoObjectOptions(cls) _meta.by_polar = True _meta.model = model _meta.registry = registry _meta.filter_fields = filter_fields _meta.fields = django_input_fields _meta.input_fields = django_input_fields _meta.connection = connection _meta.input_for = input_for super(DjangoInputObjectType, cls).__init_subclass_with_meta__(container=container, _meta=_meta, **options) if not skip_registry: registry.register(cls, for_input=input_for)
def is_type_of(cls, root, info): if isinstance(root, SimpleLazyObject): root._setup() root = root._wrapped if isinstance(root, cls): return True if not is_valid_django_model(type(root)): raise Exception(('Received incompatible instance "{}".').format(root)) return isinstance(root, cls._meta.model)
def __init__(self, _type, permission_classes=(), *args, **kwargs): kwargs.setdefault( 'id', ID(required=True, description='The ID of the object')) self.permission_classes = permission_classes assert hasattr(_type._meta, "model") and is_valid_django_model( _type._meta.model), ('only Django model is allowed') self.model = _type._meta.model super(BaseNodeField, self).__init__(_type, *args, **kwargs)
def __init_subclass_with_meta__(cls, model=None, container=None, registry=None, skip_registry=False, connection=None, use_connection=None, only_fields=(), exclude_fields=(), filter_fields=None, input_for="create", nested_fields=False, **options): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not registry: registry = get_global_registry() assert isinstance(registry, Registry), ( 'The attribute registry in {} needs to be an instance of ' 'Registry, received "{}".' ).format(cls.__name__, registry) assert input_for.lower not in ('create', 'delete', 'update'), ( 'You need to pass a valid input_for value in {}.Meta, received "{}".' ).format(cls.__name__, input_for) input_for = input_for.lower() if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception("Can only set filter_fields if Django-Filter is installed") django_fields = yank_fields_from_attrs( construct_fields(model, registry, only_fields, exclude_fields, None, nested_fields), _as=Field, sort=False ) django_input_fields = yank_fields_from_attrs( construct_fields(model, registry, only_fields, exclude_fields, input_for, nested_fields), _as=InputField, sort=False ) if container is None: container = type(cls.__name__, (InputObjectTypeContainer, cls), {}) _meta = DjangoObjectOptions(cls) _meta.by_polar = True _meta.model = model _meta.registry = registry _meta.filter_fields = filter_fields # _meta.fields = django_fields _meta.fields = django_input_fields _meta.input_fields = django_input_fields _meta.container = container _meta.connection = connection _meta.input_for = input_for super(DjangoInputObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options) if not skip_registry: registry.register(cls, for_input=input_for)
def is_type_of(cls, root, info): if isinstance(root, SimpleLazyObject): root._setup() root = root._wrapped if isinstance(root, cls): return True if not is_valid_django_model(type(root)): raise Exception(( 'Received incompatible instance "{}".' ).format(root)) model = root._meta.model return model == cls._meta.model
def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): filter_kwargs = {k: v for k, v in kwargs.items() if k in filtering_args} qs = self.get_queryset(manager, info, **kwargs) qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) if getattr(self, 'pagination', None): qs = self.pagination.paginate_queryset(qs, **kwargs) return maybe_queryset(qs)
def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): filter_kwargs = { k: v for k, v in kwargs.items() if k in filtering_args } if self.accessor: qs = getattr(root, self.accessor) if hasattr(qs, 'all'): qs = qs.all() qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs else: qs = self.get_queryset(manager, root, info, **kwargs) qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) # TODO: Duplicate count (self.pagination.paginate_queryset also calls count) count = qs.count() if getattr(self, "pagination", None): ordering = kwargs.pop(self.pagination.ordering_param, None) or self.pagination.ordering if type(self.pagination) == NoOrderingPageGraphqlPagination: # This is handled in filterset kwargs[self.pagination.ordering_param] = None else: ordering = ','.join([ to_snake_case(each) for each in ordering.strip(',').replace(' ', '').split(',') ]) kwargs[self.pagination.ordering_param] = ordering 'pageSize' in kwargs and kwargs['pageSize'] is None and kwargs.pop( 'pageSize') qs = self.pagination.paginate_queryset(qs, **kwargs) return CustomDjangoListObjectBase( count=count, results=maybe_queryset(qs), results_field_name=self.type._meta.results_field_name, page=kwargs.get('page', 1) if hasattr(self.pagination, 'page_query_param') else None, pageSize=kwargs. get( # TODO: Need to add cutoff to send max page size instead of requested 'pageSize', graphql_api_settings.DEFAULT_PAGE_SIZE) if hasattr( self.pagination, 'page_size_query_param') else None)
def __init_subclass_with_meta__(cls, model=None, results_field_name=None, pagination=None, only_fields=(), exclude_fields=(), filter_fields=None, queryset=None, **options): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception("Can only set filter_fields if Django-Filter is installed") assert isinstance(queryset, QuerySet) or queryset is None, ( 'The attribute queryset in {} needs to be an instance of ' 'Django model queryset, received "{}".' ).format(cls.__name__, queryset) results_field_name = results_field_name or 'results' baseType = get_global_registry().get_type_for_model(model) if not baseType: baseType = object_type_factory(DjangoObjectType, new_model=model, new_exclude_fields=exclude_fields, new_filter_fields=filter_fields) filter_fields = filter_fields or baseType._meta.filter_fields if pagination: result_container = pagination.get_pagination_field(baseType) else: global_paginator = graphql_api_settings.DEFAULT_PAGINATION_CLASS if global_paginator: global_paginator = global_paginator() description = '{} list, paginated by {}'.format(model.__name__, global_paginator.__name__) result_container = global_paginator.get_field(baseType, description=description) else: result_container = DjangoListField(baseType) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.queryset = queryset _meta.baseType = baseType _meta.results_field_name = results_field_name _meta.filter_fields = filter_fields _meta.exclude_fields = exclude_fields _meta.only_fields = only_fields _meta.fields = OrderedDict([ (results_field_name, result_container), ('count', Field(Int, name='totalCount', required=True, description="Total count of matches elements")) ]) super(DjangoListObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
def list_resolver(manager, filterset_class, filtering_args, root, info, **kwargs): qs = None field = None if root and is_valid_django_model(root._meta.model): available_related_fields = get_related_fields(root._meta.model) field = find_field( info.field_asts[0], available_related_fields ) filter_kwargs = { k: v for k, v in kwargs.items() if k in filtering_args } if field is not None: try: if filter_kwargs: qs = operator.attrgetter( '{}.filter'.format( getattr(field, 'related_name', None) or field.name) )(root)(**filter_kwargs) else: qs = operator.attrgetter( '{}.all'.format( getattr(field, 'related_name', None) or field.name) )(root)() except AttributeError: qs = None if qs is None: qs = queryset_factory(manager, info.field_asts, info.fragments, **kwargs) qs = filterset_class(data=filter_kwargs, queryset=qs).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) return maybe_queryset(qs)
def list_resolver(self, resolver, manager, filterset_class, filtering_args, root, info, **kwargs): qs = None field = None if root and is_valid_django_model(root._meta.model): available_related_fields = get_related_fields(root._meta.model) field = find_field(info.field_nodes[0], available_related_fields) filter_kwargs = {k: v for k, v in kwargs.items() if k in filtering_args} if field is not None: try: if filter_kwargs: qs = operator.attrgetter( "{}.filter".format( getattr(field, "related_name", None) or field.name ) )(root)(**filter_kwargs) else: qs = operator.attrgetter( "{}.all".format( getattr(field, "related_name", None) or field.name ) )(root)() except AttributeError: qs = None if qs is None: qs = self.get_queryset(manager) qs = filterset_class( data=filter_kwargs, queryset=qs, request=info.context ).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) qs = self.refactor_query(qs, info, fragments=info.fragments, **kwargs) return maybe_queryset(qs)
def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): filter_kwargs = {k: v for k, v in kwargs.items() if k in filtering_args} qs = queryset_factory(manager, info.field_asts, info.fragments, **kwargs) qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) if getattr(self, 'pagination', None): qs = self.pagination.paginate_queryset(qs, **kwargs) return maybe_queryset(qs)
def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): qs = self.get_queryset(root, info.field_name, info.field_asts, info.fragments, **kwargs) # If we've prefetched the queryset, it will be a list object and we don't need to appy the extra filters if not isinstance(qs, list) and root and is_valid_django_model( root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) if getattr(self, 'pagination', None): qs = self.pagination.paginate_queryset(qs, **kwargs) return maybe_queryset(qs)
def __init_subclass_with_meta__( cls, model=None, registry=None, skip_registry=False, only_fields=(), exclude_fields=(), filter_fields=None, interfaces=(), filterset_class=None, **options ): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not registry: registry = get_global_registry() assert isinstance(registry, Registry), ( 'The attribute registry in {} needs to be an instance of ' 'Registry, received "{}".' ).format(cls.__name__, registry) if not DJANGO_FILTER_INSTALLED and (filter_fields or filterset_class): raise Exception( "Can only set filter_fields or filterset_class if Django-Filter is installed" ) django_fields = yank_fields_from_attrs( construct_fields(model, registry, only_fields, exclude_fields), _as=Field, ) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.registry = registry _meta.filter_fields = filter_fields _meta.fields = django_fields _meta.filterset_class = filterset_class super(DjangoObjectType, cls).__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options) if not skip_registry: registry.register(cls)
def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): qs = self.get_queryset(root, info.field_name, info.field_asts, info.fragments, **kwargs) # If we've prefetched the queryset, it will be a list object and we don't need to appy the extra filters if not isinstance(qs, list) and root and is_valid_django_model( root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) count = _get_count(qs) return DjangoListObjectBase( count=count, results=maybe_queryset(qs), results_field_name=self.type._meta.results_field_name)
def list_resolver(self, manager, filterset_class, filtering_args, root, info, **kwargs): filter_kwargs = { k: v for k, v in kwargs.items() if k in filtering_args } if self.accessor: qs = getattr(root, self.accessor).all() qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs else: qs = self.get_queryset(manager, info, **kwargs) qs = filterset_class(data=filter_kwargs, queryset=qs, request=info.context).qs if root and is_valid_django_model(root._meta.model): extra_filters = get_extra_filters(root, manager.model) qs = qs.filter(**extra_filters) count = qs.count() if getattr(self, "pagination", None): ordering = kwargs.pop(self.pagination.ordering_param, None) or self.pagination.ordering ordering = ','.join([ to_snake_case(each) for each in ordering.strip(',').replace(' ', '').split(',') ]) self.pagination.ordering = ordering qs = self.pagination.paginate_queryset(qs, **kwargs) return CustomDjangoListObjectBase( count=count, results=maybe_queryset(qs), results_field_name=self.type._meta.results_field_name, page=kwargs.get('page', 1) if hasattr(self.pagination, 'page') else None, pageSize=kwargs.get( 'pageSize', graphql_api_settings.DEFAULT_PAGE_SIZE) if hasattr( self.pagination, 'page') else None)
def __init_subclass_with_meta__( cls, model=None, results_field_name=None, pagination=None, only_fields=(), exclude_fields=(), filter_fields=None, queryset=None, filterset_class=None, **options ): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception("Can only set filter_fields if Django-Filter is installed") assert isinstance(queryset, QuerySet) or queryset is None, ( 'The attribute queryset in {} needs to be an instance of ' 'Django model queryset, received "{}".' ).format(cls.__name__, queryset) results_field_name = results_field_name or 'results' baseType = get_global_registry().get_type_for_model(model) if not baseType: factory_kwargs = { 'model': model, 'only_fields': only_fields, 'exclude_fields': exclude_fields, 'filter_fields': filter_fields, 'filterset_class': filterset_class, 'pagination': pagination, 'queryset': queryset, 'skip_registry': False } baseType = factory_type('output', DjangoObjectType, **factory_kwargs) filter_fields = filter_fields or baseType._meta.filter_fields if pagination: result_container = pagination.get_pagination_field(baseType) else: global_paginator = graphql_api_settings.DEFAULT_PAGINATION_CLASS if global_paginator: assert issubclass( global_paginator, BaseDjangoGraphqlPagination ), ( 'You need to pass a valid DjangoGraphqlPagination class in {}.Meta, received "{}".' ).format(cls.__name__, global_paginator) global_paginator = global_paginator() result_container = global_paginator.get_pagination_field( baseType ) else: result_container = DjangoListField(baseType) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.queryset = queryset _meta.baseType = baseType _meta.results_field_name = results_field_name _meta.filter_fields = filter_fields _meta.exclude_fields = exclude_fields _meta.only_fields = only_fields _meta.filterset_class = filterset_class _meta.fields = OrderedDict( [ (results_field_name, result_container), ( 'count', Field( Int, name='totalCount', description="Total count of matches elements" ) ) ] ) super(DjangoListObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
def __new__(cls, name, bases, attrs): # Also ensure initialization is only performed for subclasses of # Mutation if not is_base_type(bases, ClientIDMutationMeta): return type.__new__(cls, name, bases, attrs) defaults = dict( name=name, description=attrs.pop('__doc__', None), interfaces=(), local_fields=None, permission_classes=(), throttle_classes=(), # for Django Model Permissions model=None, # for permissions method=None, # 'CREATE', 'UPDATE', 'DELETE' only this 3 accepted form_class=None, lookup_field='pk', lookup_kwarg=None ) options = Options( attrs.pop('Config', None), **defaults ) if options.model is not None: assert is_valid_django_model(options.model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(name, options.model) input_class = attrs.pop('Input', None) base_name = re.sub('Payload$', '', name) if 'client_mutation_id' not in attrs: attrs['client_mutation_id'] = String(name='clientMutationId') cls = ObjectTypeMeta.__new__(cls, '{}Payload'.format(base_name), bases, dict(attrs, _meta=options)) mutate_and_get_payload = getattr(cls, 'mutate_and_get_payload', None) if cls.mutate and cls.mutate.__func__ == ClientIDMutation.mutate.__func__: assert mutate_and_get_payload, ( "{}.mutate_and_get_payload method is required" " in a ClientIDMutation." ).format(name) input_attrs = {} bases = () if not input_class: input_attrs = {} elif not issubclass(input_class, AbstractType): input_attrs = props(input_class) else: bases += (input_class, ) input_attrs['client_mutation_id'] = String(name='clientMutationId') # If method is update and delete add id to input attrs if options.method is not None and options.method.upper() in ['UPDATE', 'DELETE']: input_attrs['id'] = String(name='id', required=True) cls.Input = type('{}Input'.format(base_name), bases + (InputObjectType,), input_attrs) cls.Field = partial(Field, cls, resolver=cls.mutate, input=Argument(cls.Input, required=True)) return cls
def __init_subclass_with_meta__(cls, model=None, results_field_name=None, pagination=None, only_fields=(), exclude_fields=(), filter_fields=None, queryset=None, filterset_class=None, **options): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception( "Can only set filter_fields if Django-Filter is installed") assert isinstance(queryset, QuerySet) or queryset is None, ( 'The attribute queryset in {} needs to be an instance of ' 'Django model queryset, received "{}".').format( cls.__name__, queryset) results_field_name = results_field_name or 'results' baseType = get_global_registry().get_type_for_model(model) if not baseType: factory_kwargs = { 'model': model, 'only_fields': only_fields, 'exclude_fields': exclude_fields, 'filter_fields': filter_fields, 'filterset_class': filterset_class, 'pagination': pagination, 'queryset': queryset, 'skip_registry': False } baseType = factory_type('output', DjangoObjectType, **factory_kwargs) filter_fields = filter_fields or baseType._meta.filter_fields if pagination: result_container = pagination.get_pagination_field(baseType) else: global_paginator = graphql_api_settings.DEFAULT_PAGINATION_CLASS if global_paginator: assert issubclass( global_paginator, BaseDjangoGraphqlPagination ), ('You need to pass a valid DjangoGraphqlPagination class in {}.Meta, received "{}".' ).format(cls.__name__, global_paginator) global_paginator = global_paginator() result_container = global_paginator.get_pagination_field( baseType) else: result_container = DjangoListField(baseType) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.queryset = queryset _meta.baseType = baseType _meta.results_field_name = results_field_name _meta.filter_fields = filter_fields _meta.exclude_fields = exclude_fields _meta.only_fields = only_fields _meta.filterset_class = filterset_class _meta.fields = OrderedDict([ (results_field_name, result_container), ('count', Field(Int, name='totalCount', description="Total count of matches elements")) ]) super(DjangoListObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
def __init_subclass_with_meta__( cls, model=None, registry=None, results_field_name=None, pagination=None, only_fields=(), exclude_fields=(), filter_fields=None, queryset=None, filterset_class=None, **options, ): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) assert pagination is None, ( 'Pagination should be applied on the ListField enclosing {0} rather than its `{0}.Meta`.' ).format(cls.__name__) if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception( "Can only set filter_fields if Django-Filter is installed") assert isinstance(queryset, QuerySet) or queryset is None, ( "The attribute queryset in {} needs to be an instance of " 'Django model queryset, received "{}".').format( cls.__name__, queryset) results_field_name = results_field_name or "results" baseType = get_global_registry().get_type_for_model(model) if not baseType: factory_kwargs = { "model": model, "only_fields": only_fields, "exclude_fields": exclude_fields, "filter_fields": filter_fields, "filterset_class": filterset_class, "pagination": pagination, "queryset": queryset, "registry": registry, "skip_registry": False, } baseType = factory_type("output", DjangoObjectType, **factory_kwargs) filter_fields = filter_fields or baseType._meta.filter_fields """ if pagination: result_container = pagination.get_pagination_field(baseType) else: global_paginator = graphql_api_settings.DEFAULT_PAGINATION_CLASS if global_paginator: assert issubclass(global_paginator, BaseDjangoGraphqlPagination), ( 'You need to pass a valid DjangoGraphqlPagination class in {}.Meta, received "{}".' ).format(cls.__name__, global_paginator) global_paginator = global_paginator() result_container = global_paginator.get_pagination_field(baseType) else: """ result_container = CustomDjangoListField(baseType) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.queryset = queryset _meta.baseType = baseType _meta.results_field_name = results_field_name _meta.filter_fields = filter_fields _meta.exclude_fields = exclude_fields _meta.only_fields = only_fields _meta.filterset_class = filterset_class _meta.fields = OrderedDict([ (results_field_name, result_container), ( "count", Field( Int, name="totalCount", description="Total count of matches elements", ), ), ( "page", Field( Int, name="page", description="Page Number", ), ), ( "pageSize", Field( Int, name="pageSize", description="Page Size", ), ) ]) super(DjangoListObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
def __init_subclass_with_meta__( cls, model=None, registry=None, skip_registry=False, only_fields=(), # deprecated in favour of `fields` fields=(), exclude_fields=(), # deprecated in favour of `exclude` exclude=(), filter_fields=None, filterset_class=None, csd_filter_fields=None, connection=None, connection_class=None, use_connection=None, interfaces=(), convert_choices_to_enum=True, _meta=None, **options, ): # if not model: # print(f'#### Model is null {cls}') # return assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not registry: registry = get_global_registry() assert isinstance(registry, Registry), ( "The attribute registry in {} needs to be an instance of " 'Registry, received "{}".').format(cls.__name__, registry) if filter_fields and filterset_class: raise Exception("Can't set both filter_fields and filterset_class") if not DJANGO_FILTER_INSTALLED and (filter_fields or filterset_class): raise Exception( ("Can only set filter_fields or filterset_class if " "Django-Filter is installed")) assert not (fields and exclude), ( "Cannot set both 'fields' and 'exclude' options on " "DjangoObjectType {class_name}.".format(class_name=cls.__name__)) # Alias only_fields -> fields if only_fields and fields: raise Exception("Can't set both only_fields and fields") if only_fields: warnings.warn( "Defining `only_fields` is deprecated in favour of `fields`.", PendingDeprecationWarning, stacklevel=2, ) fields = only_fields if fields and fields != ALL_FIELDS and not isinstance( fields, (list, tuple)): raise TypeError( 'The `fields` option must be a list or tuple or "__all__". ' "Got %s." % type(fields).__name__) if fields == ALL_FIELDS: fields = None # Alias exclude_fields -> exclude if exclude_fields and exclude: raise Exception("Can't set both exclude_fields and exclude") if exclude_fields: warnings.warn( "Defining `exclude_fields` is deprecated in favour of `exclude`.", PendingDeprecationWarning, stacklevel=2, ) exclude = exclude_fields if exclude and not isinstance(exclude, (list, tuple)): raise TypeError( "The `exclude` option must be a list or tuple. Got %s." % type(exclude).__name__) django_fields = yank_fields_from_attrs(construct_fields( model, registry, fields, exclude, convert_choices_to_enum), _as=Field) if use_connection is None and interfaces: use_connection = any( (issubclass(interface, Node) for interface in interfaces)) if use_connection and not connection: # We create the connection automatically if not connection_class: connection_class = Connection connection = connection_class.create_type("{}Connection".format( cls.__name__), node=cls) if connection is not None: assert issubclass(connection, Connection), ( "The connection must be a Connection. Received {}").format( connection.__name__) if not _meta: _meta = CsdDjangoObjectTypeOptions(cls) _meta.model = model _meta.registry = registry _meta.filter_fields = filter_fields _meta.filterset_class = filterset_class _meta.fields = django_fields _meta.connection = connection _meta.csd_filter_fields = csd_filter_fields # this is intentionally the super class of DjangObjectType and not CsdDjangoObjectType # because we do almost the same as DjangoObjectType here, so doing it twice would result # in an error. And we need to inherit from DjangoObjectType because it is hard coded # in the registry of django_graphene super(DjangoObjectType, cls).__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options) if not skip_registry: registry.register(cls)