def get_path_response(self,
path,
request,
force_download=False,
paginator=None):
self.validate_path(path)
try:
if not path:
raise OSError(errno.EISDIR, os.strerror(errno.EISDIR), path)
if os.path.isfile(self.object_path):
container_path = os.path.join(
os.path.dirname(self.object_path),
path.split('/', 1)[0])
container_path = normalize_path(container_path)
if container_path == self.object_path:
path = path.split('/', 1)[1]
fid = FormatIdentifier(allow_unknown_file_types=True)
content_type = fid.get_mimetype(path)
return generate_file_response(self.open_file(path, 'rb'),
content_type,
force_download=force_download,
name=path)
except (IOError, OSError) as e:
if e.errno == errno.ENOENT:
raise exceptions.NotFound
# Windows raises PermissionDenied (errno.EACCES) when trying to use
# open() on a directory
if os.name == 'nt':
if e.errno not in (errno.EACCES, errno.EISDIR):
raise
elif e.errno != errno.EISDIR:
raise
except IndexError:
if force_download:
fid = FormatIdentifier(allow_unknown_file_types=True)
content_type = fid.get_mimetype(path)
return generate_file_response(self.open_file(
self.object_path, 'rb'),
content_type,
force_download=force_download,
name=path)
entries = self.list_files(path)
if paginator is not None:
paginated = paginator.paginate_queryset(entries, request)
return paginator.get_paginated_response(paginated)
return Response(entries)
def test_when_force_download_and_filename_not_none_then_add_attachment(
self, get_charset, get_filename):
content_type = "text/plain"
mock_file_obj = mock.Mock()
resp = generate_file_response(mock_file_obj,
content_type,
force_download=True)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control':
'no-cache, no-store, must-revalidate',
'Pragma':
'no-cache',
'Expires':
'0',
'Content-Type':
'text/plain; charset=utf-8',
'Content-Disposition':
'attachment; filename="{}"'.format("some_file_name.txt")
})
self.assertEqual(type(resp), FileResponse)
def test_when_filename_is_not_ascii(self, get_charset):
content_type = 'text/plain'
resp = generate_file_response(
ContentFile(b'binary content', 'none_ascii_å_name.txt'),
content_type,
)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control':
'no-cache, no-store, must-revalidate',
'Pragma':
'no-cache',
'Expires':
'0',
'Content-Type':
'text/plain; charset=utf-8',
'Content-Disposition':
"inline; filename*=utf-8''{}".format(
"none_ascii_%C3%A5_name.txt")
})
self.assertEqual(type(resp), FileResponse)
def test_when_force_download_and_filename_not_none_then_add_attachment(
self, get_charset):
content_type = 'text/plain'
resp = generate_file_response(open(__file__, 'rb'),
content_type,
force_download=True)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control':
'no-cache, no-store, must-revalidate',
'Pragma':
'no-cache',
'Expires':
'0',
'Content-Type':
'text/plain; charset=utf-8',
'Content-Length':
str(os.path.getsize(__file__)),
'Content-Disposition':
'attachment; filename="{}"'.format("test_util.py")
})
self.assertEqual(type(resp), FileResponse)
def label_report(self, request, pk=None):
archive = TagVersion.objects.get(pk=pk)
agents = AgentTagLink.objects.filter(tag_id=pk).all()
series = archive.get_active_structure(
).structure.units.prefetch_related(
Prefetch(
'tagstructure_set',
queryset=TagStructure.objects.select_related(
'tag__current_version'),
to_attr='volumes',
), ).all()
template = 'tags/labels.html'.format()
f = tempfile.TemporaryFile()
ctype = 'application/pdf'
render = render_to_string(template, {
'archive_name': archive.name,
'series': series,
'agents': agents
})
HTML(string=render).write_pdf(f)
f.seek(0)
name = 'labels_{}.pdf'.format(pk)
return generate_file_response(f, content_type=ctype, name=name)
def generate_report(self, hits, format, user):
try:
tag_versions = [hit.get('_source').get('name') for hit in hits]
except Exception:
tag_versions = hits
logger.info(
f"User '{user}' generating a {format} report, with tag versions: '{tag_versions}'"
)
template = 'tags/search_results.html'.format()
f = tempfile.TemporaryFile()
formatted_hits = []
for hit in hits:
hit = hit['_source']
try:
hit['archive'] = get_archive(hit['archive'])
except KeyError:
pass
formatted_hits.append(hit)
if format == 'pdf':
ctype = 'application/pdf'
render = render_to_string(template, {
'hits': formatted_hits,
'user': user,
'timestamp': timezone.now()
})
HTML(string=render).write_pdf(f)
elif format == 'csv':
ctype = 'text/csv'
writer = csv.writer(f)
for hit in formatted_hits:
writer.writerow([
hit.get('archive', {}).get('name'),
hit.get('name'),
hit.get('reference_code'),
hit.get('name'),
hit.get('unit_dates', {}).get('date'),
hit.get('desc')
])
else:
raise ValueError('Unsupported format {}'.format(format))
f.seek(0)
name = 'search_results_{time}_{user}.{format}'.format(
time=timezone.localtime(), user=user.username, format=format)
return generate_file_response(f, content_type=ctype, name=name)
def test_win1252_and_no_filename_then_return_without_content_dispo(
self, mock_get_charset, mock_get_filename):
content_type = 'text/plain'
mock_file_obj = mock.Mock()
resp = generate_file_response(mock_file_obj, content_type)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control': 'no-cache, no-store, must-revalidate',
'Pragma': 'no-cache',
'Expires': '0',
'Content-Type': 'text/plain; charset=windows-1252',
})
self.assertEqual(type(resp), FileResponse)
def test_win1252_and_no_filename_then_return_without_content_dispo(
self, mock_get_charset, mock_get_filename):
content_type = 'text/plain'
resp = generate_file_response(open(__file__, 'rb'), content_type)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control': 'no-cache, no-store, must-revalidate',
'Pragma': 'no-cache',
'Expires': '0',
'Content-Length': str(os.path.getsize(__file__)),
'Content-Type': 'text/plain; charset=windows-1252',
})
self.assertEqual(type(resp), FileResponse)
def test_when_utf8_and_no_filename(self, get_charset, get_filename):
content_type = 'text/plain'
resp = generate_file_response(open(__file__, 'rb'), content_type)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control':
'no-cache, no-store, must-revalidate',
'Pragma':
'no-cache',
'Expires':
'0',
'Content-Length':
str(os.path.getsize(__file__)),
'Content-Type':
'text/plain; charset=utf-8',
'Content-Disposition':
'inline; filename="{}"'.format(os.path.basename(__file__)),
})
self.assertEqual(type(resp), FileResponse)
def test_win1252_and_file_obj_has_name_then_return_inline_file_response(
self, get_charset, get_filename):
content_type = 'text/plain'
mock_file_obj = mock.Mock()
resp = generate_file_response(mock_file_obj, content_type)
headers = self.get_headers_from_response(resp)
self.assertEqual(
headers, {
'Cache-Control':
'no-cache, no-store, must-revalidate',
'Pragma':
'no-cache',
'Expires':
'0',
'Content-Type':
'text/plain; charset=windows-1252',
'Content-Disposition':
'inline; filename="{}"'.format("some_file_name.txt")
})
self.assertEqual(type(resp), FileResponse)
def generate_report(self, hits, format, user):
try:
tag_versions = [hit.get('_source').get('name') for hit in hits]
except Exception:
tag_versions = hits
logger.info(f"User '{user}' generating a {format} report, with tag versions: '{tag_versions}'")
template = 'tags/search_results.html'.format()
f = tempfile.TemporaryFile()
formatted_hits = []
for hit in hits:
hit = hit['_source']
try:
hit['archive'] = get_archive(hit['archive'])
except KeyError:
pass
formatted_hits.append(hit)
if format == 'pdf':
ctype = 'application/pdf'
render = render_to_string(template, {'hits': formatted_hits, 'user': user, 'timestamp': timezone.now()})
HTML(string=render).write_pdf(f)
elif format == 'csv':
ctype = 'text/csv'
writer = csv.writer(f)
for hit in formatted_hits:
writer.writerow(
[hit.get('archive', {}).get('name'), hit.get('name'), hit.get('reference_code'), hit.get('name'),
hit.get('unit_dates', {}).get('date'), hit.get('desc')])
else:
raise ValueError('Unsupported format {}'.format(format))
f.seek(0)
name = 'search_results_{time}_{user}.{format}'.format(time=timezone.localtime(), user=user.username,
format=format)
return generate_file_response(f, content_type=ctype, name=name)
def export(request):
data = get_data()
try:
fields = request.query_params['fields'].split(',')
except KeyError:
fields = []
if fields:
try:
data = {k: data[k] for k in fields}
except KeyError as e:
raise exceptions.ParseError('Unknown field: {}'.format(e))
template = 'stats/export.html'.format()
f = tempfile.TemporaryFile()
ctype = 'application/pdf'
render = render_to_string(template, {'data': data})
HTML(string=render).write_pdf(f)
f.seek(0)
name = 'stats_{}.pdf'.format(timezone.now())
return generate_file_response(f, content_type=ctype, name=name)
def report(self, request, pk=None):
path = self.get_report_pdf_path(pk)
return generate_file_response(open(path, 'rb'), 'application/pdf')
def report(self, request, pk=None):
path = self.get_object()._get_report_directory()
path = os.path.join(path, pk + '.pdf')
return generate_file_response(open(path, 'rb'), 'application/pdf')
