mirror of
https://github.com/encode/django-rest-framework.git
synced 2024-09-21 11:29:01 +03:00
399 lines
13 KiB
Python
399 lines
13 KiB
Python
"""
|
|
Generic views that provide commonly needed behaviour.
|
|
"""
|
|
from __future__ import unicode_literals
|
|
from rest_framework import views, mixins
|
|
from rest_framework.settings import api_settings
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.core.paginator import Paginator, InvalidPage
|
|
from django.http import Http404
|
|
from django.shortcuts import get_object_or_404
|
|
from django.utils.translation import ugettext as _
|
|
|
|
|
|
class GenericAPIView(views.APIView):
|
|
"""
|
|
Base class for all other generic views.
|
|
"""
|
|
|
|
# You'll need to either set these attributes,
|
|
# or override `get_queryset`/`get_serializer_class`.
|
|
queryset = None
|
|
serializer_class = None
|
|
|
|
# If you want to use object lookups other than pk, set this attribute.
|
|
lookup_field = 'pk'
|
|
|
|
# Pagination settings
|
|
paginate_by = api_settings.PAGINATE_BY
|
|
paginate_by_param = api_settings.PAGINATE_BY_PARAM
|
|
pagination_serializer_class = api_settings.DEFAULT_PAGINATION_SERIALIZER_CLASS
|
|
page_kwarg = 'page'
|
|
|
|
# The filter backend class to use for queryset filtering
|
|
filter_backend = api_settings.FILTER_BACKEND
|
|
|
|
# Determines if the view will return 200 or 404 responses for empty lists.
|
|
allow_empty = True
|
|
|
|
# This shortcut may be used instead of setting either (or both)
|
|
# of the `queryset`/`serializer_class` attributes, although using
|
|
# the explicit style is generally preferred.
|
|
model = None
|
|
|
|
# If the `model` shortcut is used instead of `serializer_class`, then the
|
|
# serializer class will be constructed using this class as the base.
|
|
model_serializer_class = api_settings.DEFAULT_MODEL_SERIALIZER_CLASS
|
|
|
|
_paginator_class = Paginator
|
|
|
|
######################################
|
|
# These are pending deprecation...
|
|
|
|
pk_url_kwarg = 'pk'
|
|
slug_url_kwarg = 'slug'
|
|
slug_field = 'slug'
|
|
|
|
def get_serializer_context(self):
|
|
"""
|
|
Extra context provided to the serializer class.
|
|
"""
|
|
return {
|
|
'request': self.request,
|
|
'format': self.format_kwarg,
|
|
'view': self
|
|
}
|
|
|
|
def get_serializer(self, instance=None, data=None,
|
|
files=None, many=False, partial=False):
|
|
"""
|
|
Return the serializer instance that should be used for validating and
|
|
deserializing input, and for serializing output.
|
|
"""
|
|
serializer_class = self.get_serializer_class()
|
|
context = self.get_serializer_context()
|
|
return serializer_class(instance, data=data, files=files,
|
|
many=many, partial=partial, context=context)
|
|
|
|
def get_pagination_serializer(self, page):
|
|
"""
|
|
Return a serializer instance to use with paginated data.
|
|
"""
|
|
class SerializerClass(self.pagination_serializer_class):
|
|
class Meta:
|
|
object_serializer_class = self.get_serializer_class()
|
|
|
|
pagination_serializer_class = SerializerClass
|
|
context = self.get_serializer_context()
|
|
return pagination_serializer_class(instance=page, context=context)
|
|
|
|
def paginate_queryset(self, queryset, page_size=None):
|
|
"""
|
|
Paginate a queryset if required, either returning a page object,
|
|
or `None` if pagination is not configured for this view.
|
|
"""
|
|
deprecated_style = False
|
|
if page_size is not None:
|
|
# TODO: Deperecation warning
|
|
deprecated_style = True
|
|
else:
|
|
# Determine the required page size.
|
|
# If pagination is not configured, simply return None.
|
|
page_size = self.get_paginate_by()
|
|
if not page_size:
|
|
return None
|
|
|
|
paginator = self._paginator_class(queryset, page_size,
|
|
allow_empty_first_page=self.allow_empty)
|
|
page_kwarg = self.kwargs.get(self.page_kwarg)
|
|
page_query_param = self.request.QUERY_PARAMS.get(self.page_kwarg)
|
|
page = page_kwarg or page_query_param or 1
|
|
try:
|
|
page_number = int(page)
|
|
except ValueError:
|
|
if page == 'last':
|
|
page_number = paginator.num_pages
|
|
else:
|
|
raise Http404(_("Page is not 'last', nor can it be converted to an int."))
|
|
try:
|
|
page = paginator.page(page_number)
|
|
except InvalidPage as e:
|
|
raise Http404(_('Invalid page (%(page_number)s): %(message)s') % {
|
|
'page_number': page_number,
|
|
'message': str(e)
|
|
})
|
|
|
|
if deprecated_style:
|
|
return (paginator, page, page.object_list, page.has_other_pages())
|
|
return page
|
|
|
|
def filter_queryset(self, queryset):
|
|
"""
|
|
Given a queryset, filter it with whichever filter backend is in use.
|
|
|
|
You are unlikely to want to override this method, although you may need
|
|
to call it either from a list view, or from a custom `get_object`
|
|
method if you want to apply the configured filtering backend to the
|
|
default queryset.
|
|
"""
|
|
if not self.filter_backend:
|
|
return queryset
|
|
backend = self.filter_backend()
|
|
return backend.filter_queryset(self.request, queryset, self)
|
|
|
|
########################
|
|
### The following methods provide default implementations
|
|
### that you may want to override for more complex cases.
|
|
|
|
def get_paginate_by(self, queryset=None):
|
|
"""
|
|
Return the size of pages to use with pagination.
|
|
|
|
If `PAGINATE_BY_PARAM` is set it will attempt to get the page size
|
|
from a named query parameter in the url, eg. ?page_size=100
|
|
|
|
Otherwise defaults to using `self.paginate_by`.
|
|
"""
|
|
if queryset is not None:
|
|
pass # TODO: Deprecation warning
|
|
|
|
if self.paginate_by_param:
|
|
query_params = self.request.QUERY_PARAMS
|
|
try:
|
|
return int(query_params[self.paginate_by_param])
|
|
except (KeyError, ValueError):
|
|
pass
|
|
|
|
return self.paginate_by
|
|
|
|
def get_serializer_class(self):
|
|
"""
|
|
Return the class to use for the serializer.
|
|
Defaults to using `self.serializer_class`.
|
|
|
|
You may want to override this if you need to provide different
|
|
serializations depending on the incoming request.
|
|
|
|
(Eg. admins get full serialization, others get basic serilization)
|
|
"""
|
|
serializer_class = self.serializer_class
|
|
if serializer_class is not None:
|
|
return serializer_class
|
|
|
|
class DefaultSerializer(self.model_serializer_class):
|
|
class Meta:
|
|
model = self.model
|
|
return DefaultSerializer
|
|
|
|
def get_queryset(self):
|
|
"""
|
|
Get the list of items for this view.
|
|
This must be an iterable, and may be a queryset.
|
|
Defaults to using `self.queryset`.
|
|
|
|
You may want to override this if you need to provide different
|
|
querysets depending on the incoming request.
|
|
|
|
(Eg. return a list of items that is specific to the user)
|
|
"""
|
|
if self.queryset is not None:
|
|
return self.queryset._clone()
|
|
|
|
if self.model is not None:
|
|
return self.model._default_manager.all()
|
|
|
|
raise ImproperlyConfigured("'%s' must define 'queryset' or 'model'"
|
|
% self.__class__.__name__)
|
|
|
|
def get_object(self, queryset=None):
|
|
"""
|
|
Returns the object the view is displaying.
|
|
|
|
You may want to override this if you need to provide non-standard
|
|
queryset lookups. Eg if objects are referenced using multiple
|
|
keyword arguments in the url conf.
|
|
"""
|
|
# Determine the base queryset to use.
|
|
if queryset is None:
|
|
queryset = self.filter_queryset(self.get_queryset())
|
|
else:
|
|
pass # Deprecation warning
|
|
|
|
# Perform the lookup filtering.
|
|
pk = self.kwargs.get(self.pk_url_kwarg, None)
|
|
slug = self.kwargs.get(self.slug_url_kwarg, None)
|
|
lookup = self.kwargs.get(self.lookup_field, None)
|
|
|
|
if lookup is not None:
|
|
filter_kwargs = {self.lookup_field: lookup}
|
|
elif pk is not None:
|
|
# TODO: Deprecation warning
|
|
filter_kwargs = {'pk': pk}
|
|
elif slug is not None:
|
|
# TODO: Deprecation warning
|
|
filter_kwargs = {self.slug_field: slug}
|
|
else:
|
|
# TODO: Fix error message
|
|
raise AttributeError("Generic detail view %s must be called with "
|
|
"either an object pk or a slug."
|
|
% self.__class__.__name__)
|
|
|
|
obj = get_object_or_404(queryset, **filter_kwargs)
|
|
|
|
# May raise a permission denied
|
|
self.check_object_permissions(self.request, obj)
|
|
|
|
return obj
|
|
|
|
########################
|
|
### The following are placeholder methods,
|
|
### and are intended to be overridden.
|
|
###
|
|
### The are not called by GenericAPIView directly,
|
|
### but are used by the mixin methods.
|
|
|
|
def pre_save(self, obj):
|
|
"""
|
|
Placeholder method for calling before saving an object.
|
|
|
|
May be used to set attributes on the object that are implicit
|
|
in either the request, or the url.
|
|
"""
|
|
pass
|
|
|
|
def post_save(self, obj, created=False):
|
|
"""
|
|
Placeholder method for calling after saving an object.
|
|
"""
|
|
pass
|
|
|
|
|
|
##########################################################
|
|
### Concrete view classes that provide method handlers ###
|
|
### by composing the mixin classes with the base view. ###
|
|
##########################################################
|
|
|
|
class CreateAPIView(mixins.CreateModelMixin,
|
|
GenericAPIView):
|
|
|
|
"""
|
|
Concrete view for creating a model instance.
|
|
"""
|
|
def post(self, request, *args, **kwargs):
|
|
return self.create(request, *args, **kwargs)
|
|
|
|
|
|
class ListAPIView(mixins.ListModelMixin,
|
|
GenericAPIView):
|
|
"""
|
|
Concrete view for listing a queryset.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
return self.list(request, *args, **kwargs)
|
|
|
|
|
|
class RetrieveAPIView(mixins.RetrieveModelMixin,
|
|
GenericAPIView):
|
|
"""
|
|
Concrete view for retrieving a model instance.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
return self.retrieve(request, *args, **kwargs)
|
|
|
|
|
|
class DestroyAPIView(mixins.DestroyModelMixin,
|
|
GenericAPIView):
|
|
|
|
"""
|
|
Concrete view for deleting a model instance.
|
|
"""
|
|
def delete(self, request, *args, **kwargs):
|
|
return self.destroy(request, *args, **kwargs)
|
|
|
|
|
|
class UpdateAPIView(mixins.UpdateModelMixin,
|
|
GenericAPIView):
|
|
|
|
"""
|
|
Concrete view for updating a model instance.
|
|
"""
|
|
def put(self, request, *args, **kwargs):
|
|
return self.update(request, *args, **kwargs)
|
|
|
|
def patch(self, request, *args, **kwargs):
|
|
return self.partial_update(request, *args, **kwargs)
|
|
|
|
|
|
class ListCreateAPIView(mixins.ListModelMixin,
|
|
mixins.CreateModelMixin,
|
|
GenericAPIView):
|
|
"""
|
|
Concrete view for listing a queryset or creating a model instance.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
return self.list(request, *args, **kwargs)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
return self.create(request, *args, **kwargs)
|
|
|
|
|
|
class RetrieveUpdateAPIView(mixins.RetrieveModelMixin,
|
|
mixins.UpdateModelMixin,
|
|
GenericAPIView):
|
|
"""
|
|
Concrete view for retrieving, updating a model instance.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
return self.retrieve(request, *args, **kwargs)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
return self.update(request, *args, **kwargs)
|
|
|
|
def patch(self, request, *args, **kwargs):
|
|
return self.partial_update(request, *args, **kwargs)
|
|
|
|
|
|
class RetrieveDestroyAPIView(mixins.RetrieveModelMixin,
|
|
mixins.DestroyModelMixin,
|
|
GenericAPIView):
|
|
"""
|
|
Concrete view for retrieving or deleting a model instance.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
return self.retrieve(request, *args, **kwargs)
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
return self.destroy(request, *args, **kwargs)
|
|
|
|
|
|
class RetrieveUpdateDestroyAPIView(mixins.RetrieveModelMixin,
|
|
mixins.UpdateModelMixin,
|
|
mixins.DestroyModelMixin,
|
|
GenericAPIView):
|
|
"""
|
|
Concrete view for retrieving, updating or deleting a model instance.
|
|
"""
|
|
def get(self, request, *args, **kwargs):
|
|
return self.retrieve(request, *args, **kwargs)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
return self.update(request, *args, **kwargs)
|
|
|
|
def patch(self, request, *args, **kwargs):
|
|
return self.partial_update(request, *args, **kwargs)
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
return self.destroy(request, *args, **kwargs)
|
|
|
|
|
|
##########################
|
|
### Deprecated classes ###
|
|
##########################
|
|
|
|
class MultipleObjectAPIView(GenericAPIView):
|
|
pass
|
|
|
|
|
|
class SingleObjectAPIView(GenericAPIView):
|
|
pass
|