def get_file(self):
queryset = self.get_document_queryset()
zip_filename = self.request.GET.get('zip_filename',
DEFAULT_ZIP_FILENAME)
if self.request.GET.get(
'compressed') == 'True' or queryset.count() > 1:
compressed_file = CompressedFile()
for item in queryset:
descriptor = item.open()
compressed_file.add_file(
descriptor,
arcname=DocumentDownloadView.get_item_label(item=item))
descriptor.close()
DocumentDownloadView.commit_event(item=item,
request=self.request)
compressed_file.close()
return DocumentDownloadView.VirtualFile(
compressed_file.as_file(zip_filename), name=zip_filename)
else:
item = queryset.first()
if item:
DocumentDownloadView.commit_event(item=item,
request=self.request)
else:
raise PermissionDenied
return DocumentDownloadView.VirtualFile(
DocumentDownloadView.get_item_file(item=item),
name=DocumentDownloadView.get_item_label(item=item))
def upload_file(self, file_object, filename=None, use_file_name=False, document_type=None, expand=False, metadata_dict_list=None, user=None, document=None, new_version_data=None, command_line=False):
is_compressed = None
if expand:
try:
cf = CompressedFile(file_object)
count = 1
for fp in cf.children():
if command_line:
print 'Uploading file #%d: %s' % (count, fp)
self.upload_single_file(file_object=fp, filename=None, document_type=document_type, metadata_dict_list=metadata_dict_list, user=user)
fp.close()
count += 1
except NotACompressedFile:
is_compressed = False
logging.debug('Exception: NotACompressedFile')
if command_line:
raise
self.upload_single_file(file_object=file_object, filename=filename, document_type=document_type, metadata_dict_list=metadata_dict_list, user=user)
else:
is_compressed = True
else:
self.upload_single_file(file_object, filename, use_file_name, document_type, metadata_dict_list, user, document, new_version_data)
file_object.close()
return {'is_compressed': is_compressed}
def handle_upload(self, file_object, description=None, document_type=None, expand=False, label=None, language=None, metadata_dict_list=None, metadata_dictionary=None, user=None):
if not document_type:
document_type = self.document_type
kwargs = {
'description': description, 'document_type': document_type,
'label': label, 'language': language,
'metadata_dict_list': metadata_dict_list,
'metadata_dictionary': metadata_dictionary, 'user': user
}
if expand:
try:
compressed_file = CompressedFile(file_object)
for compressed_file_child in compressed_file.children():
kwargs.update({'label': force_text(compressed_file_child)})
self.upload_document(
file_object=File(compressed_file_child), **kwargs
)
compressed_file_child.close()
except NotACompressedFile:
logging.debug('Exception: NotACompressedFile')
self.upload_document(file_object=file_object, **kwargs)
else:
self.upload_document(file_object=file_object, **kwargs)
def handle_upload(self, file_object, description=None, document_type=None, expand=False, label=None, language=None, metadata_dict_list=None, metadata_dictionary=None, tag_ids=None, user=None):
"""
Handle an upload request from a file object which may be an individual
document or a compressed file containing multiple documents.
"""
if not document_type:
document_type = self.document_type
kwargs = {
'description': description, 'document_type': document_type,
'label': label, 'language': language,
'metadata_dict_list': metadata_dict_list,
'metadata_dictionary': metadata_dictionary, 'tag_ids': tag_ids,
'user': user
}
if expand:
try:
compressed_file = CompressedFile(file_object)
for compressed_file_child in compressed_file.children():
kwargs.update({'label': force_text(compressed_file_child)})
self.upload_document(
file_object=File(compressed_file_child), **kwargs
)
compressed_file_child.close()
except NotACompressedFile:
logging.debug('Exception: NotACompressedFile')
self.upload_document(file_object=file_object, **kwargs)
else:
self.upload_document(file_object=file_object, **kwargs)
def handle_upload(self,
file_object,
description=None,
document_type=None,
expand=False,
label=None,
language=None,
user=None):
"""
Handle an upload request from a file object which may be an individual
document or a compressed file containing multiple documents.
"""
documents = []
if not document_type:
document_type = self.document_type
kwargs = {
'description': description,
'document_type': document_type,
'label': label,
'language': language,
'user': user
}
if expand:
try:
compressed_file = CompressedFile(file_object)
for compressed_file_child in compressed_file.children():
kwargs.update({'label': force_text(compressed_file_child)})
documents.append(
self.upload_document(
file_object=File(compressed_file_child), **kwargs))
compressed_file_child.close()
except NotACompressedFile:
logging.debug('Exception: NotACompressedFile')
documents.append(
self.upload_document(file_object=file_object, **kwargs))
else:
documents.append(
self.upload_document(file_object=file_object, **kwargs))
# Return a list of newly created documents. Used by the email source
# to assign the from and subject metadata values.
return documents
def new_document(self, document_type, file_object, label=None, command_line=False, description=None, expand=False, language=None, user=None):
versions_created = []
if expand:
try:
compressed_file = CompressedFile(file_object)
count = 1
for compressed_file_child in compressed_file.children():
if command_line:
print 'Uploading file #%d: %s' % (count, compressed_file_child)
versions_created.append(self.upload_single_document(document_type=document_type, file_object=compressed_file_child, description=description, label=unicode(compressed_file_child), language=language or LANGUAGE, user=user))
compressed_file_child.close()
count += 1
except NotACompressedFile:
logging.debug('Exception: NotACompressedFile')
if command_line:
raise
versions_created.append(self.upload_single_document(document_type=document_type, file_object=file_object, description=description, label=label, language=language or LANGUAGE, user=user))
else:
versions_created.append(self.upload_single_document(document_type=document_type, file_object=file_object, description=description, label=label, language=language or LANGUAGE, user=user))
return versions_created
def task_source_handle_upload(self,
document_type_id,
shared_uploaded_file_id,
source_id,
description=None,
expand=False,
label=None,
language=None,
metadata_dict_list=None,
skip_list=None,
tag_ids=None,
user_id=None):
SharedUploadedFile = apps.get_model(app_label='common',
model_name='SharedUploadedFile')
DocumentType = apps.get_model(app_label='documents',
model_name='DocumentType')
try:
document_type = DocumentType.objects.get(pk=document_type_id)
shared_upload = SharedUploadedFile.objects.get(
pk=shared_uploaded_file_id)
if not label:
label = shared_upload.filename
except OperationalError as exception:
logger.warning(
'Operational error during attempt to load data to handle source '
'upload: %s. Retrying.', exception)
raise self.retry(exc=exception)
kwargs = {
'description': description,
'document_type_id': document_type.pk,
'label': label,
'language': language,
'metadata_dict_list': metadata_dict_list,
'source_id': source_id,
'tag_ids': tag_ids,
'user_id': user_id
}
if not skip_list:
skip_list = []
with shared_upload.open() as file_object:
if expand:
try:
compressed_file = CompressedFile(file_object)
for compressed_file_child in compressed_file.children():
# TODO: find way to uniquely identify child files
# Use filename in the mean time.
if force_text(compressed_file_child) not in skip_list:
kwargs.update(
{'label': force_text(compressed_file_child)})
try:
child_shared_uploaded_file = SharedUploadedFile.objects.create(
file=File(compressed_file_child))
except OperationalError as exception:
logger.warning(
'Operational error while preparing to upload '
'child document: %s. Rescheduling.', exception)
task_source_handle_upload.delay(
document_type_id=document_type_id,
shared_uploaded_file_id=shared_uploaded_file_id,
source_id=source_id,
description=description,
expand=expand,
label=label,
language=language,
metadata_dict_list=metadata_dict_list,
skip_list=skip_list,
tag_ids=tag_ids,
user_id=user_id)
return
else:
skip_list.append(force_text(compressed_file_child))
task_upload_document.delay(
shared_uploaded_file_id=
child_shared_uploaded_file.pk,
**kwargs)
finally:
compressed_file_child.close()
compressed_file_child.close()
try:
shared_upload.delete()
except OperationalError as exception:
logger.warning(
'Operational error during attempt to delete shared '
'upload file: %s; %s. Retrying.', shared_upload,
exception)
except NotACompressedFile:
logging.debug('Exception: NotACompressedFile')
task_upload_document.delay(
shared_uploaded_file_id=shared_upload.pk, **kwargs)
else:
task_upload_document.delay(
shared_uploaded_file_id=shared_upload.pk, **kwargs)
def document_download(request,
document_id=None,
document_id_list=None,
document_version_pk=None):
previous = request.POST.get(
'previous',
request.GET.get(
'previous',
request.META.get('HTTP_REFERER',
reverse(settings.LOGIN_REDIRECT_URL))))
if document_id:
documents = Document.objects.filter(pk=document_id)
elif document_id_list:
documents = Document.objects.filter(pk__in=document_id_list)
elif document_version_pk:
documents = Document.objects.filter(pk=get_object_or_404(
DocumentVersion, pk=document_version_pk).document.pk)
try:
Permission.check_permissions(request.user,
(permission_document_download, ))
except PermissionDenied:
documents = AccessControlList.objects.filter_by_access(
permission_document_download, request.user, documents)
if not documents:
messages.error(request,
_('Must provide at least one document or version.'))
return HttpResponseRedirect(
request.META.get('HTTP_REFERER',
reverse(settings.LOGIN_REDIRECT_URL)))
if document_version_pk:
queryset = DocumentVersion.objects.filter(pk=document_version_pk)
else:
queryset = DocumentVersion.objects.filter(
pk__in=[document.latest_version.pk for document in documents])
subtemplates_list = []
subtemplates_list.append({
'name': 'appearance/generic_list_subtemplate.html',
'context': {
'title':
_('Documents to be downloaded'),
'object_list':
queryset,
'hide_link':
True,
'hide_object':
True,
'hide_links':
True,
'scrollable_content':
True,
'scrollable_content_height':
'200px',
'extra_columns': (
{
'name': _('Document'),
'attribute': 'document'
},
{
'name': _('Date and time'),
'attribute': 'timestamp'
},
{
'name': _('MIME type'),
'attribute': 'mimetype'
},
{
'name': _('Encoding'),
'attribute': 'encoding'
},
),
}
})
if request.method == 'POST':
form = DocumentDownloadForm(request.POST, queryset=queryset)
if form.is_valid():
if form.cleaned_data['compressed'] or queryset.count() > 1:
try:
compressed_file = CompressedFile()
for document_version in queryset:
descriptor = document_version.open()
compressed_file.add_file(
descriptor,
arcname=document_version.document.label)
descriptor.close()
compressed_file.close()
return serve_file(request,
compressed_file.as_file(
form.cleaned_data['zip_filename']),
save_as='"%s"' %
form.cleaned_data['zip_filename'],
content_type='application/zip')
except Exception as exception:
if settings.DEBUG:
raise
else:
messages.error(request, exception)
return HttpResponseRedirect(
request.META['HTTP_REFERER'])
else:
try:
# Test permissions and trigger exception
fd = queryset.first().open()
fd.close()
return serve_file(request,
queryset.first().file,
save_as='"%s"' %
queryset.first().document.label,
content_type=queryset.first().mimetype
if queryset.first().mimetype else
'application/octet-stream')
except Exception as exception:
if settings.DEBUG:
raise
else:
messages.error(request, exception)
return HttpResponseRedirect(
request.META['HTTP_REFERER'])
else:
form = DocumentDownloadForm(queryset=queryset)
context = {
'form': form,
'previous': previous,
'submit_label': _('Download'),
'subtemplates_list': subtemplates_list,
'title': _('Download documents'),
}
if queryset.count() == 1:
context['object'] = queryset.first().document
return render_to_response('appearance/generic_form.html',
context,
context_instance=RequestContext(request))
