def determine_version(self, request, *args, **kwargs):
"""Use either Accept header or query parameter for versioning."""
# Patterned after rest_framework.versioning.AcceptHeaderVersioning
media_type = _MediaType(request.accepted_media_type)
header_version = media_type.params.get(self.header_version_param, None)
if header_version is not None:
header_version = unicode_http_header(header_version)
# Patterned after rest_framework.versioning.QueryParameterVersioning
query_version = request.query_params.get(self.query_version_param,
None)
if header_version is not None and query_version is not None and header_version != query_version:
raise APIVersionMismatch()
if header_version is not None and not self.is_allowed_version(
header_version):
# Behave like AcceptHeaderVersioning
raise exceptions.NotAcceptable(self.invalid_version_in_header)
if query_version is not None and not self.is_allowed_version(
query_version):
# Behave like QueryParameterVersioning
raise exceptions.NotFound(self.invalid_version_in_query)
version = header_version or query_version or self.default_version
# self.default_version is always allowed, no need to re-check is_allowed_version here
return version
def determine_version(self, request, *args, **kwargs):
media_type = _MediaType(request.accepted_media_type)
version = media_type.params.get(self.version_param, self.default_version)
version = unicode_http_header(version)
if not self.is_allowed_version(version):
raise exceptions.NotAcceptable(self.invalid_version_message)
return version
def determine_version(self, request, *args, **kwargs):
media_type = _MediaType(request.META.get('HTTP_ACCEPT'))
version = media_type.params.get(self.version_param, 0)
version = unicode_http_header(version)
if not version and request.path.startswith('/schema'):
version = request.GET.get('version', self.allowed_versions[-1])
if version not in self.allowed_versions:
raise exceptions.NotAcceptable({
'detail': "Invalid version in 'Accept' header.",
'allowed_versions': [
int(v) for v in self.allowed_versions
],
'valid_content_types': [
media_type_format_json,
media_type_format_xml,
media_type_format_yaml,
],
'example_header': (
f'Accept: {media_type_format_json}; '
f'version={self.allowed_versions[-1]}'
)
})
request.version = version
return version
def determine_version(self, request, *args, **kwargs):
version = request.META.get('HTTP_API_VERSION')
if version == None:
version = settings.DEFAULT_API_VERSION
version = unicode_http_header(version)
if not self.is_allowed_version(version):
raise exceptions.NotAcceptable(self.invalid_version_message)
return version
def get_header_version(self, request):
invalid_version_message = 'Invalid version in "Accept" header.'
media_type = _MediaType(request.accepted_media_type)
version = media_type.params.get(self.version_param)
if not version:
return None
version = unicode_http_header(version)
if not self.is_allowed_version(version):
raise drf_exceptions.NotAcceptable(invalid_version_message)
return version
def get_header_version(self, request):
invalid_version_message = 'Invalid version in "Accept" header.'
media_type = _MediaType(request.accepted_media_type)
version = media_type.params.get(self.version_param)
if not version:
return None
version = unicode_http_header(version)
if not self.is_allowed_version(version):
raise drf_exceptions.NotAcceptable(invalid_version_message)
return version
def determine_version(self, request, *args, **kwargs):
major_version = super(APlusVersioning, self).determine_version(request, *args, **kwargs)
api_version = self.allowed_versions[major_version]
## get and update version in request media type
# this is only location where need to check the requested version and we
# update the version so the respond content type has the correct version
media_type = _MediaType(request.accepted_media_type)
accept_version = unicode_http_header(media_type.params.get(self.version_param, ''))
media_type.params[self.version_param] = api_version
request.accepted_media_type = str(media_type)
if accept_version:
accept_major_version = accept_version.split('.', 1)[0]
if accept_major_version != major_version or _version(api_version) < _version(accept_version):
raise exceptions.NotAcceptable(self.invalid_accept_version_message)
return major_version
def determine_version(self, request, *args, **kwargs):
major_version = super(APlusVersioning,
self).determine_version(request, *args, **kwargs)
api_version = self.allowed_versions[major_version]
## get and update version in request media type
# this is only location where need to check the requested version and we
# update the version so the respond content type has the correct version
media_type = _MediaType(request.accepted_media_type)
accept_version = unicode_http_header(
media_type.params.get(self.version_param, ''))
media_type.params[self.version_param] = api_version
request.accepted_media_type = str(media_type)
if accept_version:
accept_major_version = accept_version.split('.', 1)[0]
if accept_major_version != major_version or _version(
api_version) < _version(accept_version):
raise exceptions.NotAcceptable(
self.invalid_accept_version_message)
return major_version
def __init__(self, *args, **kwargs):
super(_MediaType, self).__init__(*args, **kwargs)
self.params = dict(
((k, unicode_http_header(v)) for k, v in self.params.items()))
def __init__(self, *args, **kwargs):
super(_MediaType, self).__init__(*args, **kwargs)
self.params = dict(((k, unicode_http_header(v)) for k, v in self.params.items()))
def determine_version(request):
media_type = _MediaType(request.META.get("HTTP_ACCEPT"))
version = media_type.params.get("version")
version = unicode_http_header(version)
return version or None
