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)
