def get_file_report(self, request, pk=None):
try:
ext = request.GET['extension']
except KeyError:
lh.error('missing get parameter: extension')
raise exceptions.ParseError(
detail='missing get parameter: extension')
try:
debtor = Debtor.objects.get(id=pk)
except Debtor.DoesNotExist:
raise exceptions.NotFound()
self.check_object_permissions(self.request, debtor)
try:
report_obj = ReportGenerator(ext, debtor).get_report()
except KeyError:
lh.error(f'report format not supported: {ext}')
raise exceptions.UnsupportedMediaType(ext)
except IndexError:
lh.error('The debtor has no transactions')
raise exceptions.NotFound(detail='The debtor has no transactions')
report_obj.seek(0)
try:
mimetypes.types_map[f'.{ext}']
except KeyError:
lh.error('mimetype is not in mime.types file or windows registry')
raise exceptions.UnsupportedMediaType(ext)
response = HttpResponse(report_obj.read(),
mimetypes.types_map[f'.{ext}'])
report_date = datetime.now().strftime('%d-%m_%Y')
response[
'Content-Disposition'] = f'attachment; filename="report_{report_date}.{ext}"'
return response
def _parse(self):
"""
Parse the request content, returning a two-tuple of (data, files)
May raise an `UnsupportedMediaType`, or `ParseError` exception.
"""
stream = self.stream
media_type = self.content_type
if stream is None or media_type is None:
return (None, None)
parser = self.negotiator.select_parser(self, self.parsers)
if not parser:
raise exceptions.UnsupportedMediaType(media_type)
parsed = parser.parse(stream, media_type, self.parser_context)
# Parser classes may return the raw data, or a
# DataAndFiles object. Unpack the result as required.
try:
return (parsed.data, parsed.files)
except AttributeError:
return (parsed, None)
def validate_file(f, whitelist):
if f:
ext = os.path.splitext(f.name)[1]
ext = ext.lower().replace('.', '')
if ext not in whitelist:
msg = '{0} is not a valid map image file type. '
msg += 'Valid options are: {1}'
raise exceptions.UnsupportedMediaType(f,
msg.format(ext, whitelist))
def _parse(self):
"""
Parse the request content, returning a two-tuple of (data, files)
May raise an `UnsupportedMediaType`, or `ParseError` exception.
## 解析请求内容，返回一个元组 (data, files)
## self 是请求对象
"""
## 用户提交的请求头中的 Content-Type 的值
media_type = self.content_type
try:
stream = self.stream
except RawPostDataException:
if not hasattr(self._request, '_post'):
raise
# If request.POST has been accessed in middleware, and a method='POST'
# request was made with 'multipart/form-data', then the request stream
# will already have been exhausted.
if self._supports_form_parsing():
return (self._request.POST, self._request.FILES)
stream = None
if stream is None or media_type is None:
if media_type and is_form_media_type(media_type):
empty_data = QueryDict('', encoding=self._request._encoding)
else:
empty_data = {}
empty_files = MultiValueDict()
return (empty_data, empty_files)
## 选择合适的解析器
parser = self.negotiator.select_parser(self, self.parsers)
if not parser:
raise exceptions.UnsupportedMediaType(media_type)
try:
## 调用解析器的 parse 方法解析数据
parsed = parser.parse(stream, media_type, self.parser_context)
except Exception:
# If we get an exception during parsing, fill in empty data and
# re-raise. Ensures we don't simply repeat the error when
# attempting to render the browsable renderer response, or when
# logging the request or similar.
self._data = QueryDict('', encoding=self._request._encoding)
self._files = MultiValueDict()
self._full_data = self._data
raise
# Parser classes may return the raw data, or a
# DataAndFiles object. Unpack the result as required.
try:
return (parsed.data, parsed.files)
except AttributeError:
empty_files = MultiValueDict()
return (parsed, empty_files)
def post(self, request):
xlsx = request.FILES.get('file')
if xlsx is None:
raise BadRequest()
if xlsx.content_type != self.content_type:
raise exceptions.UnsupportedMediaType(xlsx.content_type)
table = Workbook.objects.create(owner=request.user,
data=xlsx.read(),
filename=xlsx.name)
return Response(WorkbookSerializer(table).data, status=200)
def test_unsupported_media_type_exception() -> None:
response = exception_handler(
exceptions.UnsupportedMediaType("application/xml"))
assert response is not None
assert response.status_code == status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
assert response.data == {
"type": "invalid_request",
"code": "unsupported_media_type",
"detail": 'Unsupported media type "application/xml" in request.',
"attr": None,
}
def post(self, request):
self.check_permissions(request)
if 'guestPostId' not in request.data:
raise exceptions.UnsupportedMediaType('Guest Post ID is missing!')
guest_post = GuestPost.objects.get(pk=request.data.get('guestPostId'))
if guest_post.owner == request.user:
raise exceptions.PermissionDenied(
'You can\'t apply to your own guest post')
application = GuestSpeakingApplication(
guest_post=guest_post,
application_message=request.data.get('applicationMessage', ' '),
applicant=request.user)
send_application(application, guest_post)
application.save()
applications_left = APPLICATIONS_ALLOWED_PER_MONTH - get_applications_sent_this_month_by_user(
request.user)
return Response({'remainingApplications': applications_left},
status=status.HTTP_201_CREATED)
def _parse(self):
"""
Parse the request content, returning a two-tuple of (data, files)
May raise an `UnsupportedMediaType`, or `ParseError` exception.
"""
stream = self.stream
media_type = self.content_type
if stream is None or media_type is None:
empty_data = QueryDict('', encoding=self._request._encoding)
empty_files = MultiValueDict()
return (empty_data, empty_files)
parser = self.negotiator.select_parser(self, self.parsers)
if not parser:
raise exceptions.UnsupportedMediaType(media_type)
try:
parsed = parser.parse(stream, media_type, self.parser_context)
except:
# If we get an exception during parsing, fill in empty data and
# re-raise. Ensures we don't simply repeat the error when
# attempting to render the browsable renderer response, or when
# logging the request or similar.
self._data = QueryDict('', encoding=self._request._encoding)
self._files = MultiValueDict()
self._full_data = self._data
raise
# Parser classes may return the raw data, or a
# DataAndFiles object. Unpack the result as required.
try:
return (parsed.data, parsed.files)
except AttributeError:
empty_files = MultiValueDict()
return (parsed, empty_files)
class UnsupportedMediaTypeView(BaseErrorView):
exception = exceptions.UnsupportedMediaType(
"application/xml", detail="This media type is not supported")
def list(self, request, *args, **kwargs):
raise exceptions.UnsupportedMediaType("application/unknown")
def get_serializer_class(self, item):
if item not in self._allowed_types:
raise excepts.UnsupportedMediaType(media_type=item)
item = "One{}Serializer".format(item.title())
return getattr(self.serializer_classes, item)
from exception_dispatcher.handlers import exception_handler
@pytest.mark.parametrize(
'exception',
[
exceptions.APIException('detail', 'code'),
exceptions.AuthenticationFailed(),
exceptions.MethodNotAllowed('GET'),
exceptions.NotAcceptable(),
exceptions.NotAuthenticated(),
exceptions.NotFound(),
exceptions.ParseError(),
exceptions.PermissionDenied(),
exceptions.Throttled(),
exceptions.UnsupportedMediaType('application/vnd.skarzi+json'),
exceptions.ValidationError(),
# special cases of `django` exceptions
PermissionDenied(),
Http404(),
])
def test_rest_framework_exception(exception):
"""Ensure response returned by our and rest_framework handler are equal."""
rest_framework_response = rest_exception_handler(exception, {})
response = exception_handler(exception, {})
assert rest_framework_response
assert response
assert response.status_code == rest_framework_response.status_code
assert set(response.items()) == set(rest_framework_response.items())
def _parse(self):
"""
Parse the request content, returning a two-tuple of (data, files)
May raise an `UnsupportedMediaType`, or `ParseError` exception.
解析请求内容，返货两个元组(数据、文件)
可能引发"UnsupportedMediaType"或者“ParseError”异常
"""
# 获取请求体中的content-type
media_type = self.content_type
try:
# 如果是文件数据,则获取文件流数据
stream = self.stream
except RawPostDataException:
if not hasattr(self._request, '_post'):
raise
# If request.POST has been accessed in middleware, and a method='POST'
# request was made with 'multipart/form-data', then the request stream
# will already have been exhausted.
# 如果是form表单
if self._supports_form_parsing():
# 处理文件类型数据
return (self._request.POST, self._request.FILES)
stream = None
# 如果文件流为空,和media_type也为空
if stream is None or media_type is None:
if media_type and is_form_media_type(media_type):
empty_data = QueryDict('', encoding=self._request._encoding)
else:
empty_data = {}
empty_files = MultiValueDict()
return (empty_data, empty_files)
# 选择解析器
parser = self.negotiator.select_parser(self, self.parsers)
# 没有解析器则抛出异常
if not parser:
raise exceptions.UnsupportedMediaType(media_type)
try:
# 执行解析器的parse方法(从这里可以看出每个解析器都必须有该方法),对请求数据进行解析
parsed = parser.parse(stream, media_type, self.parser_context)
except Exception:
# If we get an exception during parsing, fill in empty data and
# re-raise. Ensures we don't simply repeat the error when
# attempting to render the browsable renderer response, or when
# logging the request or similar.
self._data = QueryDict('', encoding=self._request._encoding)
self._files = MultiValueDict()
self._full_data = self._data
raise
# Parser classes may return the raw data, or a
# DataAndFiles object. Unpack the result as required.
try:
# 返回解析结果, 元组,解析后的数据parsed.data(在load_data_and_files中
# 使用self._data和self._files进行接受)
# 文件数据咋parsed.files中
return (parsed.data, parsed.files)
except AttributeError:
empty_files = MultiValueDict()
return (parsed, empty_files)
