def select_parser(self, request, parsers):
if request.method == 'POST':
parsers = [FormParser(), MultiPartParser()]
return super(ConditionalContentNegotiation, self).select_parser(
request, parsers
)
def select_parser(self, request, parsers):
"""
Always return JSONParser unless a 'multipart/form-data' content type is sent
"""
if "multipart" in request.content_type:
return MultiPartParser()
return JSONParser()
def test_form_POST_unicode(self):
"""
JSON POST via default web interface with unicode data
"""
# Note: environ and other variables here have simplified content compared to real Request
CONTENT = b'_content_type=application%2Fjson&_content=%7B%22request%22%3A+4%2C+%22firm%22%3A+1%2C+%22text%22%3A+%22%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D1%82%21%22%7D'
environ = {
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': 'application/x-www-form-urlencoded',
'CONTENT_LENGTH': len(CONTENT),
'wsgi.input': BytesIO(CONTENT),
}
wsgi_request = WSGIRequest(environ=environ)
wsgi_request._load_post_and_files()
parsers = (JSONParser(), FormParser(), MultiPartParser())
parser_context = {
'encoding': 'utf-8',
'kwargs': {},
'args': (),
}
request = Request(wsgi_request,
parsers=parsers,
parser_context=parser_context)
method = request.method
self.assertEqual(method, 'POST')
self.assertEqual(request._content_type, 'application/json')
self.assertEqual(
request._stream.getvalue(),
b'{"request": 4, "firm": 1, "text": "\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82!"}'
)
self.assertEqual(request._data, Empty)
self.assertEqual(request._files, Empty)
def test_request_DATA_with_form_content(self):
"""
Ensure request.DATA returns content for POST request with form content.
"""
data = {'qwerty': 'uiop'}
request = Request(factory.post('/', data))
request.parsers = (FormParser(), MultiPartParser())
self.assertEqual(list(request.DATA.items()), list(data.items()))
def test_request_POST_with_form_content(self):
"""
Ensure request.POST returns content for POST request with form content.
"""
data = {'qwerty': 'uiop'}
request = Request(factory.post('/', data))
request.parsers = (FormParser(), MultiPartParser())
assert list(request.POST.items()) == list(data.items())
def test_post_accessed_in_put_method(self):
django_request = self.factory.put('/', {'foo': 'bar'})
request = Request(django_request,
parsers=[FormParser(),
MultiPartParser()])
django_request.POST
assert request.POST == {'foo': ['bar']}
assert request.data == {'foo': ['bar']}
def test_standard_behaviour_determines_form_content_PUT(self):
"""
Ensure request.data returns content for PUT request with form content.
"""
data = {'qwerty': 'uiop'}
request = Request(factory.put('/', data))
request.parsers = (FormParser(), MultiPartParser())
assert list(request.data.items()) == list(data.items())
def test_request_POST_with_form_content_JSONField(self):
data = b'-----------------------------20775962551482475149231161538\r\nContent-Disposition: form-data; name="json_field"\r\n\r\n{"a": true}\r\n-----------------------------20775962551482475149231161538--\r\n'
content_type = 'multipart/form-data; boundary=---------------------------20775962551482475149231161538'
wsgi_request = self.factory.generic('POST', '/', data, content_type)
request = Request(wsgi_request)
request.parsers = (FormParser(), MultiPartParser())
serializer = self.Serializer(data=request.data)
assert serializer.is_valid(raise_exception=True) == True
assert dict(serializer.data)['json_field'] == {'a': True}
def put(self, request, code, suggested_format=None):
"""Used to work with "update" sequence of DMS code.
to update a code you need to send a PUT request here.
PUT must contain:
@param code: the DMS "code" of file to be updated. e.g.: ADL-0001
@param suggested_format: format of file for code to be updated. To have ability to post files in certain format.
"""
context = {'request': request}
conten_type = request.content_type
uploaded_obj = None
if 'multipart/form-data' in conten_type:
# We have a file upload encoded with multipart/form-data
file_content = StringIO(request.body)
parser = MultiPartParser()
dnf = parser.parse(file_content,
media_type=conten_type,
parser_context=context)
extra = dnf.data
if 'file' in dnf.files:
uploaded_obj = dnf.files['file']
else:
extra = request.QUERY_PARAMS
# TODO: do we require SQL tagging logic in this API call?
sql_tag_string = extra.get('tag_string', None)
sql_remove_tag_string = extra.get('remove_tag_string', None)
new_name = extra.get('new_name', None)
new_type = extra.get('new_type', None)
index_data = extra.get('indexing_data', None)
if index_data:
index_data = json.loads(index_data)
processor = DocumentProcessor()
options = {
'tag_string': sql_tag_string,
'remove_tag_string': sql_remove_tag_string,
'extension': suggested_format,
'new_name': new_name,
'new_type': new_type,
'new_indexes': index_data,
'update_file': uploaded_obj,
'user': request.user,
}
document = processor.update(code, options)
if len(processor.errors) > 0:
log.error('FileHandler.update manager errors %s' %
processor.errors)
if settings.DEBUG:
print processor.errors
raise Exception('FileHandler.update manager errors')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
log.info(
'FileHandler.update request fulfilled for code: %s, extension: %s'
% (code, suggested_format))
resp = DMSOBjectRevisionsData(document).data
return Response(resp, status=status.HTTP_200_OK)
def test_request_POST_with_files(self):
"""
Ensure request.POST returns no content for POST request with file content.
"""
upload = SimpleUploadedFile("file.txt", b"file_content")
request = Request(factory.post('/', {'upload': upload}))
request.parsers = (FormParser(), MultiPartParser())
assert list(request.POST.keys()) == []
assert list(request.FILES.keys()) == ['upload']
def testupload(self):
"""
Ensure request.POST returns no content for POST request with file content.
"""
factory = APIRequestFactory()
upload = SimpleUploadedFile("file.txt", b"file_content")
request = Request(factory.post('App/upload', {'upload': upload}))
request.parsers = (FormParser(), MultiPartParser())
assert list(request.POST) == []
assert list(request.FILES) == ['upload']
def test_request_read_before_parsing(self):
django_request = self.factory.put('/', {'foo': 'bar'})
request = Request(django_request,
parsers=[FormParser(),
MultiPartParser()])
django_request.read()
with pytest.raises(RawPostDataException):
request.POST
with pytest.raises(RawPostDataException):
request.POST
request.data
def test_standard_behaviour_determines_form_content_PUT(self):
"""
Ensure request.DATA returns content for PUT request with form content.
"""
data = {'qwerty': 'uiop'}
from django import VERSION
if VERSION >= (1, 5):
from django.test.client import MULTIPART_CONTENT, BOUNDARY, encode_multipart
request = Request(factory.put('/', encode_multipart(BOUNDARY, data),
content_type=MULTIPART_CONTENT))
else:
request = Request(factory.put('/', data))
request.parsers = (FormParser(), MultiPartParser())
self.assertEqual(list(request.DATA.items()), list(data.items()))
def update(request, pk):
try:
recipe = Recipe.objects.get(id=pk)
except Recipe.DoesNotExist:
return JsonResponse({'error': 'choose a valid Recipe'})
parser = MultiPartParser(request.META, request, request.upload_handlers)
POST, FILES = parser.parse()
data = {}
data['header'] = POST.get('header')
data['serves'] = POST.get('serves')
data['url'] = POST.get('url')
data['description'] = POST.get('description')
data['ingredients'] = json.loads(POST.get('ingredients'))
data['instructions'] = json.loads(POST.get('instructions'))
if not FILES.get('image'):
data['image'] = POST.get('image')
else:
data['image'] = FILES.get('image')
recipe = Recipe.objects.updateRecipeData(recipe, data, data['image'])
return redirect('/recipe/' + str(pk))
def get_parsers(self):
if self.request.method in ["PUT", "PATCH"]:
return [MultiPartParser()]
return super().get_parsers()
def request(self, *args, **kwargs):
return Request(super().request(*args, **kwargs),
parsers=[MultiPartParser(),
JSONParser()])
def create(self, request, *args, **kwargs):
try:
req_params = MultiPartParser().parse(request)
compiler = req_params.pop("compiler")
tex_source = req_params.pop("tex_source")
tex_key = req_params.pop("tex_key", None)
field_str = req_params.pop("fields", None)
except Exception:
from traceback import print_exc
print_exc()
tp, e, __ = sys.exc_info()
error = "%s: %s" % (tp.__name__, str(e))
return Response({"error": error},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if field_str and tex_key:
cached_result = (get_cached_results_from_field_and_tex_key(
tex_key, field_str, request))
if cached_result:
return Response(cached_result, status=status.HTTP_200_OK)
data_url = None
error = None
try:
_converter = unzipped_folder_to_pdf_converter(
compiler, tex_source, image_format, tex_key, **req_params)
except Exception as e:
from traceback import print_exc
print_exc()
tp, e, __ = sys.exc_info()
error = "%s: %s" % (tp.__name__, str(e))
return Response({"error": error},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
qs = LatexPdf.objects.filter(
project__zip_file_hash=_converter.zip_file_hash)
if qs.count():
instance = qs[0]
image_serializer = self.get_serializer(instance, fields=field_str)
return Response(image_serializer.data, status=status.HTTP_200_OK)
try:
data_url = _converter.get_converted_data_url()
except Exception as e:
if isinstance(e, LatexCompileError):
error = "%s: %s" % (type(e).__name__, str(e))
else:
from traceback import print_exc
print_exc()
tp, e, __ = sys.exc_info()
error = "%s: %s" % (tp.__name__, str(e))
return Response({"error": error},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
assert not all([data_url is None, error is None])
data = {"tex_key": _converter.zip_file_hash}
if data_url is not None:
data["data_url"] = data_url
else:
data["compile_error"] = error
data["creator"] = self.request.user.pk
image_serializer = self.get_serializer(data=data)
if image_serializer.is_valid():
instance = image_serializer.save()
return Response(self.get_serializer(instance,
fields=field_str).data,
status=status.HTTP_201_CREATED)
return Response(
# For example, tex_key already exists.
image_serializer.errors,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)