django-rest-framework/rest_framework/mixins.py

177 lines
5.9 KiB
Python
Raw Normal View History

"""
Basic building blocks for generic class based views.
We don't bind behaviour to http method handlers yet,
which allows mixin classes to be composed in interesting ways.
"""
2012-11-22 03:20:49 +04:00
from __future__ import unicode_literals
2012-09-30 20:31:28 +04:00
from django.http import Http404
from rest_framework import status
from rest_framework.response import Response
2013-02-10 20:50:46 +04:00
from rest_framework.request import clone_request
def _get_validation_exclusions(obj, pk=None, slug_field=None, lookup_field=None):
2013-02-23 02:02:42 +04:00
"""
Given a model instance, and an optional pk and slug field,
return the full list of all other field names on that model.
For use when performing full_clean on a model instance,
so we only clean the required fields.
"""
include = []
if pk:
# Pending deprecation
2013-02-23 02:02:42 +04:00
pk_field = obj._meta.pk
while pk_field.rel:
pk_field = pk_field.rel.to._meta.pk
include.append(pk_field.name)
if slug_field:
# Pending deprecation
2013-02-23 02:02:42 +04:00
include.append(slug_field)
if lookup_field and lookup_field != 'pk':
include.append(lookup_field)
2013-02-23 02:02:42 +04:00
return [field.name for field in obj._meta.fields if field.name not in include]
class CreateModelMixin(object):
"""
Create a model instance.
Should be mixed in with any `GenericAPIView`.
"""
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2013-01-02 17:39:24 +04:00
if serializer.is_valid():
2012-10-25 15:15:31 +04:00
self.pre_save(serializer.object)
self.object = serializer.save(force_insert=True)
2013-02-07 01:28:03 +04:00
self.post_save(self.object, created=True)
headers = self.get_success_headers(serializer.data)
2013-01-02 17:39:24 +04:00
return Response(serializer.data, status=status.HTTP_201_CREATED,
headers=headers)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
2012-11-14 16:24:20 +04:00
def get_success_headers(self, data):
try:
return {'Location': data['url']}
except (TypeError, KeyError):
return {}
class ListModelMixin(object):
"""
List a queryset.
Should be mixed in with `MultipleObjectAPIView`.
"""
2012-11-22 03:20:49 +04:00
empty_error = "Empty list and '%(class_name)s.allow_empty' is False."
2012-09-30 20:31:28 +04:00
def list(self, request, *args, **kwargs):
self.object_list = self.filter_queryset(self.get_queryset())
2012-09-30 20:31:28 +04:00
# Default is to allow empty querysets. This can be altered by setting
# `.allow_empty = False`, to raise 404 errors on empty querysets.
if not self.allow_empty and not self.object_list:
class_name = self.__class__.__name__
error_msg = self.empty_error % {'class_name': class_name}
raise Http404(error_msg)
2012-09-30 20:31:28 +04:00
2013-04-25 20:40:17 +04:00
# Switch between paginated or standard style responses
page = self.paginate_queryset(self.object_list)
if page is not None:
2012-09-30 20:31:28 +04:00
serializer = self.get_pagination_serializer(page)
else:
serializer = self.get_serializer(self.object_list, many=True)
2012-09-30 20:31:28 +04:00
return Response(serializer.data)
class RetrieveModelMixin(object):
"""
Retrieve a model instance.
Should be mixed in with `SingleObjectAPIView`.
"""
def retrieve(self, request, *args, **kwargs):
self.object = self.get_object()
2012-11-06 21:04:48 +04:00
serializer = self.get_serializer(self.object)
return Response(serializer.data)
class UpdateModelMixin(object):
"""
Update a model instance.
Should be mixed in with `SingleObjectAPIView`.
"""
2013-01-02 17:39:24 +04:00
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
2013-02-07 01:28:03 +04:00
self.object = None
2012-10-05 19:24:52 +04:00
try:
self.object = self.get_object()
except Http404:
2013-02-10 20:50:46 +04:00
# If this is a PUT-as-create operation, we need to ensure that
# we have relevant permissions, as if this was a POST request.
self.check_permissions(clone_request(request, 'POST'))
2013-02-07 01:28:03 +04:00
created = True
save_kwargs = {'force_insert': True}
2013-01-02 17:39:24 +04:00
success_status_code = status.HTTP_201_CREATED
2013-02-07 01:28:03 +04:00
else:
created = False
save_kwargs = {'force_update': True}
2013-02-07 01:28:03 +04:00
success_status_code = status.HTTP_200_OK
2012-10-05 19:24:52 +04:00
2013-01-02 17:39:24 +04:00
serializer = self.get_serializer(self.object, data=request.DATA,
files=request.FILES, partial=partial)
2012-10-08 15:52:56 +04:00
if serializer.is_valid():
2012-10-25 15:15:31 +04:00
self.pre_save(serializer.object)
self.object = serializer.save(**save_kwargs)
2013-02-07 01:28:03 +04:00
self.post_save(self.object, created=created)
2013-01-02 17:39:24 +04:00
return Response(serializer.data, status=success_status_code)
2012-10-08 15:52:56 +04:00
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
2013-04-05 01:24:30 +04:00
def partial_update(self, request, *args, **kwargs):
kwargs['partial'] = True
return self.update(request, *args, **kwargs)
2012-10-25 15:15:31 +04:00
def pre_save(self, obj):
2012-10-05 19:24:52 +04:00
"""
2012-10-25 15:15:31 +04:00
Set any attributes on the object that are implicit in the request.
2012-10-05 19:24:52 +04:00
"""
2012-10-25 15:15:31 +04:00
# pk and/or slug attributes are implicit in the URL.
lookup = self.kwargs.get(self.lookup_field, None)
2012-10-05 19:24:52 +04:00
pk = self.kwargs.get(self.pk_url_kwarg, None)
2013-02-23 02:02:42 +04:00
slug = self.kwargs.get(self.slug_url_kwarg, None)
slug_field = slug and self.slug_field or None
2013-02-23 02:02:42 +04:00
if lookup:
setattr(obj, self.lookup_field, lookup)
2012-10-05 19:24:52 +04:00
if pk:
setattr(obj, 'pk', pk)
if slug:
setattr(obj, slug_field, slug)
# Ensure we clean the attributes so that we don't eg return integer
# pk using a string representation, as provided by the url conf kwarg.
2013-01-02 17:39:24 +04:00
if hasattr(obj, 'full_clean'):
exclude = _get_validation_exclusions(obj, pk, slug_field, self.lookup_field)
2013-02-23 02:02:42 +04:00
obj.full_clean(exclude)
class DestroyModelMixin(object):
"""
Destroy a model instance.
Should be mixed in with `SingleObjectAPIView`.
"""
def destroy(self, request, *args, **kwargs):
obj = self.get_object()
obj.delete()
return Response(status=status.HTTP_204_NO_CONTENT)