1081 lines
44 KiB
Python
1081 lines
44 KiB
Python
import urlparse
|
|
import copy
|
|
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.http import HttpResponseRedirect
|
|
from django.shortcuts import render_to_response, get_object_or_404
|
|
from django.template import RequestContext
|
|
from django.contrib import messages
|
|
from django.views.generic.list_detail import object_list
|
|
from django.core.urlresolvers import reverse
|
|
from django.views.generic.create_update import delete_object, update_object
|
|
from django.utils.http import urlencode
|
|
|
|
import sendfile
|
|
from common.utils import pretty_size, parse_range, urlquote, \
|
|
return_diff
|
|
from common.widgets import two_state_template
|
|
from common.literals import PAGE_SIZE_DIMENSIONS, \
|
|
PAGE_ORIENTATION_PORTRAIT, PAGE_ORIENTATION_LANDSCAPE
|
|
from common.conf.settings import DEFAULT_PAPER_SIZE
|
|
from converter.literals import DEFAULT_ZOOM_LEVEL, DEFAULT_ROTATION, \
|
|
DEFAULT_FILE_FORMAT, DEFAULT_PAGE_NUMBER
|
|
from filetransfers.api import serve_file
|
|
from grouping.utils import get_document_group_subtemplate
|
|
from metadata.forms import MetadataFormSet, MetadataSelectionForm
|
|
from navigation.utils import resolve_to_name
|
|
from permissions.api import check_permissions
|
|
from document_indexing.api import update_indexes, delete_indexes
|
|
from history.api import create_history
|
|
|
|
from documents.conf.settings import PREVIEW_SIZE
|
|
from documents.conf.settings import STORAGE_BACKEND
|
|
from documents.conf.settings import ZOOM_PERCENT_STEP
|
|
from documents.conf.settings import ZOOM_MAX_LEVEL
|
|
from documents.conf.settings import ZOOM_MIN_LEVEL
|
|
from documents.conf.settings import ROTATION_STEP
|
|
from documents.conf.settings import PRINT_SIZE
|
|
from documents.conf.settings import RECENT_COUNT
|
|
|
|
from documents.literals import PERMISSION_DOCUMENT_CREATE, \
|
|
PERMISSION_DOCUMENT_PROPERTIES_EDIT, \
|
|
PERMISSION_DOCUMENT_VIEW, \
|
|
PERMISSION_DOCUMENT_DELETE, PERMISSION_DOCUMENT_DOWNLOAD, \
|
|
PERMISSION_DOCUMENT_TRANSFORM, \
|
|
PERMISSION_DOCUMENT_EDIT
|
|
from documents.literals import HISTORY_DOCUMENT_CREATED, \
|
|
HISTORY_DOCUMENT_EDITED, HISTORY_DOCUMENT_DELETED
|
|
|
|
from documents.forms import DocumentTypeSelectForm, \
|
|
DocumentForm_edit, DocumentPropertiesForm, \
|
|
DocumentPreviewForm, \
|
|
DocumentPageForm, DocumentPageTransformationForm, \
|
|
DocumentContentForm, DocumentPageForm_edit, \
|
|
DocumentPageForm_text, PrintForm, DocumentTypeForm, \
|
|
DocumentTypeFilenameForm, DocumentTypeFilenameForm_create
|
|
from documents.wizards import DocumentCreateWizard
|
|
from documents.models import Document, DocumentType, DocumentPage, \
|
|
DocumentPageTransformation, RecentDocument, DocumentTypeFilename
|
|
|
|
# Document type permissions
|
|
from documents.literals import PERMISSION_DOCUMENT_TYPE_EDIT, \
|
|
PERMISSION_DOCUMENT_TYPE_DELETE, PERMISSION_DOCUMENT_TYPE_CREATE
|
|
|
|
|
|
def document_list(request, object_list=None, title=None, extra_context=None):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
context = {
|
|
'object_list': object_list if not (object_list is None) else Document.objects.only('file_filename', 'file_extension').all(),
|
|
'title': title if title else _(u'documents'),
|
|
'multi_select_as_buttons': True,
|
|
'hide_links': True,
|
|
}
|
|
if extra_context:
|
|
context.update(extra_context)
|
|
|
|
return render_to_response('generic_list.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_create(request):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_CREATE])
|
|
|
|
wizard = DocumentCreateWizard(form_list=[DocumentTypeSelectForm, MetadataSelectionForm, MetadataFormSet])
|
|
|
|
return wizard(request)
|
|
|
|
|
|
def document_create_siblings(request, document_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_CREATE])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
query_dict = {}
|
|
for pk, metadata in enumerate(document.documentmetadata_set.all()):
|
|
query_dict['metadata%s_id' % pk] = metadata.metadata_type_id
|
|
query_dict['metadata%s_value' % pk] = metadata.value
|
|
|
|
if document.document_type_id:
|
|
query_dict['document_type_id'] = document.document_type_id
|
|
|
|
url = reverse('upload_interactive')
|
|
return HttpResponseRedirect('%s?%s' % (url, urlencode(query_dict)))
|
|
|
|
|
|
def document_view(request, document_id, advanced=False):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
#document = get_object_or_404(Document.objects.select_related(), pk=document_id)
|
|
# Triggers a 404 error on documents uploaded via local upload
|
|
# TODO: investigate
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
|
|
RecentDocument.objects.add_document_for_user(request.user, document)
|
|
|
|
subtemplates_list = []
|
|
|
|
if advanced:
|
|
document_properties_form = DocumentPropertiesForm(instance=document, extra_fields=[
|
|
{'label': _(u'Filename'), 'field': 'file_filename'},
|
|
{'label': _(u'File extension'), 'field': 'file_extension'},
|
|
{'label': _(u'File mimetype'), 'field': 'file_mimetype'},
|
|
{'label': _(u'File mime encoding'), 'field': 'file_mime_encoding'},
|
|
{'label': _(u'File size'), 'field':lambda x: pretty_size(x.file.storage.size(x.file.path)) if x.exists() else '-'},
|
|
{'label': _(u'Exists in storage'), 'field': 'exists'},
|
|
{'label': _(u'File path in storage'), 'field': 'file'},
|
|
{'label': _(u'Date added'), 'field':lambda x: x.date_added.date()},
|
|
{'label': _(u'Time added'), 'field':lambda x: unicode(x.date_added.time()).split('.')[0]},
|
|
{'label': _(u'Checksum'), 'field': 'checksum'},
|
|
{'label': _(u'UUID'), 'field': 'uuid'},
|
|
{'label': _(u'Pages'), 'field': lambda x: x.documentpage_set.count()},
|
|
])
|
|
|
|
subtemplates_list.append(
|
|
{
|
|
'name': 'generic_form_subtemplate.html',
|
|
'context': {
|
|
'form': document_properties_form,
|
|
'object': document,
|
|
'title': _(u'document properties for: %s') % document,
|
|
}
|
|
},
|
|
)
|
|
else:
|
|
preview_form = DocumentPreviewForm(document=document)
|
|
subtemplates_list.append(
|
|
{
|
|
'name': 'generic_form_subtemplate.html',
|
|
'context': {
|
|
'form': preview_form,
|
|
'object': document,
|
|
}
|
|
},
|
|
)
|
|
|
|
content_form = DocumentContentForm(document=document)
|
|
|
|
subtemplates_list.append(
|
|
{
|
|
'name': 'generic_form_subtemplate.html',
|
|
'context': {
|
|
'title': _(u'document data'),
|
|
'form': content_form,
|
|
'object': document,
|
|
},
|
|
}
|
|
)
|
|
|
|
document_group_subtemplate = get_document_group_subtemplate(request, document)
|
|
|
|
if document_group_subtemplate:
|
|
subtemplates_list.append(document_group_subtemplate)
|
|
|
|
return render_to_response('generic_detail.html', {
|
|
'object': document,
|
|
'document': document,
|
|
'subtemplates_list': subtemplates_list,
|
|
'disable_auto_focus': True,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_delete(request, document_id=None, document_id_list=None):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_DELETE])
|
|
post_action_redirect = None
|
|
|
|
if document_id:
|
|
documents = [get_object_or_404(Document, pk=document_id)]
|
|
post_action_redirect = reverse('document_list')
|
|
elif document_id_list:
|
|
documents = [get_object_or_404(Document, pk=document_id) for document_id in document_id_list.split(',')]
|
|
else:
|
|
messages.error(request, _(u'Must provide at least one document.'))
|
|
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
|
|
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/')))
|
|
next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/')))
|
|
|
|
if request.method == 'POST':
|
|
for document in documents:
|
|
try:
|
|
warnings = delete_indexes(document)
|
|
if request.user.is_staff or request.user.is_superuser:
|
|
for warning in warnings:
|
|
messages.warning(request, warning)
|
|
|
|
document.delete()
|
|
#create_history(HISTORY_DOCUMENT_DELETED, data={'user': request.user, 'document': document})
|
|
messages.success(request, _(u'Document: %s deleted successfully.') % document)
|
|
except Exception, e:
|
|
messages.error(request, _(u'Document: %(document)s delete error: %(error)s') % {
|
|
'document': document, 'error': e
|
|
})
|
|
|
|
return HttpResponseRedirect(next)
|
|
|
|
context = {
|
|
'object_name': _(u'document'),
|
|
'delete_view': True,
|
|
'previous': previous,
|
|
'next': next,
|
|
'form_icon': u'page_delete.png',
|
|
}
|
|
if len(documents) == 1:
|
|
context['object'] = documents[0]
|
|
context['title'] = _(u'Are you sure you wish to delete the document: %s?') % ', '.join([unicode(d) for d in documents])
|
|
elif len(documents) > 1:
|
|
context['title'] = _(u'Are you sure you wish to delete the documents: %s?') % ', '.join([unicode(d) for d in documents])
|
|
|
|
return render_to_response('generic_confirm.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_multiple_delete(request):
|
|
return document_delete(
|
|
request, document_id_list=request.GET.get('id_list', [])
|
|
)
|
|
|
|
|
|
def document_edit(request, document_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_PROPERTIES_EDIT])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
|
|
if request.method == 'POST':
|
|
old_document = copy.copy(document)
|
|
form = DocumentForm_edit(request.POST, instance=document)
|
|
if form.is_valid():
|
|
warnings = delete_indexes(document)
|
|
if request.user.is_staff or request.user.is_superuser:
|
|
for warning in warnings:
|
|
messages.warning(request, warning)
|
|
|
|
document.file_filename = form.cleaned_data['new_filename']
|
|
document.description = form.cleaned_data['description']
|
|
|
|
if 'document_type_available_filenames' in form.cleaned_data:
|
|
if form.cleaned_data['document_type_available_filenames']:
|
|
document.file_filename = form.cleaned_data['document_type_available_filenames'].filename
|
|
|
|
document.save()
|
|
create_history(HISTORY_DOCUMENT_EDITED, document, {'user': request.user, 'diff': return_diff(old_document, document, ['file_filename', 'description'])})
|
|
RecentDocument.objects.add_document_for_user(request.user, document)
|
|
|
|
messages.success(request, _(u'Document "%s" edited successfully.') % document)
|
|
|
|
warnings = update_indexes(document)
|
|
if request.user.is_staff or request.user.is_superuser:
|
|
for warning in warnings:
|
|
messages.warning(request, warning)
|
|
|
|
return HttpResponseRedirect(document.get_absolute_url())
|
|
else:
|
|
form = DocumentForm_edit(instance=document, initial={
|
|
'new_filename': document.file_filename})
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'form': form,
|
|
'object': document,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def get_document_image(request, document_id, size=PREVIEW_SIZE):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
|
|
page = int(request.GET.get('page', DEFAULT_PAGE_NUMBER))
|
|
|
|
zoom = int(request.GET.get('zoom', DEFAULT_ZOOM_LEVEL))
|
|
|
|
if zoom < ZOOM_MIN_LEVEL:
|
|
zoom = ZOOM_MIN_LEVEL
|
|
|
|
if zoom > ZOOM_MAX_LEVEL:
|
|
zoom = ZOOM_MAX_LEVEL
|
|
|
|
rotation = int(request.GET.get('rotation', DEFAULT_ROTATION)) % 360
|
|
|
|
return sendfile.sendfile(request, document.get_image(size=size, page=page, zoom=zoom, rotation=rotation))
|
|
|
|
|
|
def document_download(request, document_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_DOWNLOAD])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
try:
|
|
#Test permissions and trigger exception
|
|
document.open()
|
|
return serve_file(
|
|
request,
|
|
document.file,
|
|
save_as=u'"%s"' % document.get_fullname(),
|
|
content_type=document.file_mimetype if document.file_mimetype else 'application/octet-stream'
|
|
)
|
|
except Exception, e:
|
|
messages.error(request, e)
|
|
return HttpResponseRedirect(request.META['HTTP_REFERER'])
|
|
|
|
|
|
def document_page_transformation_list(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM])
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
|
|
return object_list(
|
|
request,
|
|
queryset=document_page.documentpagetransformation_set.all(),
|
|
template_name='generic_list.html',
|
|
extra_context={
|
|
'object': document_page,
|
|
'title': _(u'transformations for: %s') % document_page,
|
|
'web_theme_hide_menus': True,
|
|
'extra_columns': [
|
|
{'name': _(u'order'), 'attribute': 'order'},
|
|
{'name': _(u'transformation'), 'attribute': lambda x: x.get_transformation_display()},
|
|
{'name': _(u'arguments'), 'attribute': 'arguments'}
|
|
],
|
|
'hide_link': True,
|
|
'hide_object': True,
|
|
},
|
|
)
|
|
|
|
|
|
def document_page_transformation_create(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM])
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentPageTransformationForm(request.POST, initial={'document_page': document_page})
|
|
if form.is_valid():
|
|
document_page.document.invalidate_cached_image(document_page.page_number)
|
|
form.save()
|
|
messages.success(request, _(u'Document page transformation created successfully.'))
|
|
return HttpResponseRedirect(reverse('document_page_transformation_list', args=[document_page_id]))
|
|
else:
|
|
form = DocumentPageTransformationForm(initial={'document_page': document_page})
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'form': form,
|
|
'object': document_page,
|
|
'title': _(u'Create new transformation for page: %(page)s of document: %(document)s') % {
|
|
'page': document_page.page_number, 'document': document_page.document},
|
|
'web_theme_hide_menus': True,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_page_transformation_edit(request, document_page_transformation_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM])
|
|
|
|
document_page_transformation = get_object_or_404(DocumentPageTransformation, pk=document_page_transformation_id)
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentPageTransformationForm(request.POST, instance=document_page_transformation)
|
|
if form.is_valid():
|
|
document_page_transformation.document_page.document.invalidate_cached_image(document_page_transformation.document_page.page_number)
|
|
form.save()
|
|
messages.success(request, _(u'Document page transformation edited successfully.'))
|
|
return HttpResponseRedirect(reverse('document_page_transformation_list', args=[document_page_transformation.document_page_id]))
|
|
else:
|
|
form = DocumentPageTransformationForm(instance=document_page_transformation)
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'form': form,
|
|
'object': document_page_transformation,
|
|
'object_name': _(u'transformation'),
|
|
'title': _(u'Edit transformation "%(transformation)s" for: %(document_page)s') % {
|
|
'transformation': document_page_transformation.get_transformation_display(),
|
|
'document_page': document_page_transformation.document_page},
|
|
'web_theme_hide_menus': True,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_page_transformation_delete(request, document_page_transformation_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM])
|
|
|
|
document_page_transformation = get_object_or_404(DocumentPageTransformation, pk=document_page_transformation_id)
|
|
|
|
redirect_view = reverse('document_page_transformation_list', args=[document_page_transformation.document_page_id])
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', redirect_view)))
|
|
|
|
if request.method == 'POST':
|
|
document_page_transformation.document_page.document.invalidate_cached_image(document_page_transformation.document_page.page_number)
|
|
document_page_transformation.delete()
|
|
messages.success(request, _(u'Document page transformation deleted successfully.'))
|
|
return HttpResponseRedirect(redirect_view)
|
|
|
|
return render_to_response('generic_confirm.html', {
|
|
'delete_view': True,
|
|
'object': document_page_transformation,
|
|
'object_name': _(u'transformation'),
|
|
'title': _(u'Are you sure you wish to delete transformation "%(transformation)s" for: %(document_page)s') % {
|
|
'transformation': document_page_transformation.get_transformation_display(),
|
|
'document_page': document_page_transformation.document_page},
|
|
'web_theme_hide_menus': True,
|
|
'previous': previous,
|
|
'form_icon': u'pencil_delete.png',
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_find_duplicates(request, document_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
extra_context = {
|
|
'title': _(u'duplicates of: %s') % document,
|
|
'object': document,
|
|
}
|
|
return _find_duplicate_list(request, [document], include_source=True, confirmation=False, extra_context=extra_context)
|
|
|
|
|
|
def _find_duplicate_list(request, source_document_list=Document.objects.all(), include_source=False, confirmation=True, extra_context=None):
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None)))
|
|
|
|
if confirmation and request.method != 'POST':
|
|
return render_to_response('generic_confirm.html', {
|
|
'previous': previous,
|
|
'title': _(u'Are you sure you wish to find all duplicates?'),
|
|
'message': _(u'On large databases this operation may take some time to execute.'),
|
|
'form_icon': u'page_refresh.png',
|
|
}, context_instance=RequestContext(request))
|
|
else:
|
|
duplicated = []
|
|
for document in source_document_list:
|
|
if document.pk not in duplicated:
|
|
results = Document.objects.filter(checksum=document.checksum).exclude(id__in=duplicated).exclude(pk=document.pk).values_list('pk', flat=True)
|
|
duplicated.extend(results)
|
|
|
|
if include_source and results:
|
|
duplicated.append(document.pk)
|
|
|
|
context = {
|
|
'object_list': Document.objects.filter(pk__in=duplicated),
|
|
'title': _(u'duplicated documents'),
|
|
'hide_links': True,
|
|
'multi_select_as_buttons': True,
|
|
}
|
|
|
|
if extra_context:
|
|
context.update(extra_context)
|
|
|
|
return render_to_response('generic_list.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_find_all_duplicates(request):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
return _find_duplicate_list(request, include_source=True)
|
|
|
|
|
|
def document_clear_transformations(request, document_id=None, document_id_list=None):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM])
|
|
|
|
if document_id:
|
|
documents = [get_object_or_404(Document.objects, pk=document_id)]
|
|
post_redirect = reverse('document_view_simple', args=[documents[0].pk])
|
|
elif document_id_list:
|
|
documents = [get_object_or_404(Document, pk=document_id) for document_id in document_id_list.split(',')]
|
|
post_redirect = None
|
|
else:
|
|
messages.error(request, _(u'Must provide at least one document.'))
|
|
return HttpResponseRedirect(request.META.get('HTTP_REFERER', u'/'))
|
|
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', post_redirect or reverse('document_list'))))
|
|
next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', post_redirect or reverse('document_list'))))
|
|
|
|
if request.method == 'POST':
|
|
for document in documents:
|
|
try:
|
|
for document_page in document.documentpage_set.all():
|
|
document_page.document.invalidate_cached_image(document_page.page_number)
|
|
for transformation in document_page.documentpagetransformation_set.all():
|
|
transformation.delete()
|
|
messages.success(request, _(u'All the page transformations for document: %s, have been deleted successfully.') % document)
|
|
except Exception, e:
|
|
messages.error(request, _(u'Error deleting the page transformations for document: %(document)s; %(error)s.') % {
|
|
'document': document, 'error': e})
|
|
|
|
return HttpResponseRedirect(next)
|
|
|
|
context = {
|
|
'object_name': _(u'document transformation'),
|
|
'delete_view': True,
|
|
'previous': previous,
|
|
'next': next,
|
|
'form_icon': u'page_paintbrush.png',
|
|
}
|
|
|
|
if len(documents) == 1:
|
|
context['object'] = documents[0]
|
|
context['title'] = _(u'Are you sure you wish to clear all the page transformations for document: %s?') % ', '.join([unicode(d) for d in documents])
|
|
elif len(documents) > 1:
|
|
context['title'] = _(u'Are you sure you wish to clear all the page transformations for documents: %s?') % ', '.join([unicode(d) for d in documents])
|
|
|
|
return render_to_response('generic_confirm.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_multiple_clear_transformations(request):
|
|
return document_clear_transformations(request, document_id_list=request.GET.get('id_list', []))
|
|
|
|
|
|
def document_missing_list(request):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None)))
|
|
|
|
if request.method != 'POST':
|
|
return render_to_response('generic_confirm.html', {
|
|
'previous': previous,
|
|
'message': _(u'On large databases this operation may take some time to execute.'),
|
|
}, context_instance=RequestContext(request))
|
|
else:
|
|
missing_id_list = []
|
|
for document in Document.objects.only('id',):
|
|
if not STORAGE_BACKEND().exists(document.file):
|
|
missing_id_list.append(document.pk)
|
|
|
|
return render_to_response('generic_list.html', {
|
|
'object_list': Document.objects.in_bulk(missing_id_list).values(),
|
|
'title': _(u'missing documents'),
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_page_view(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
|
|
zoom = int(request.GET.get('zoom', DEFAULT_ZOOM_LEVEL))
|
|
rotation = int(request.GET.get('rotation', DEFAULT_ROTATION))
|
|
document_page_form = DocumentPageForm(instance=document_page, zoom=zoom, rotation=rotation)
|
|
|
|
base_title = _(u'details for: %s') % document_page
|
|
|
|
if zoom != DEFAULT_ZOOM_LEVEL:
|
|
zoom_text = u'(%d%%)' % zoom
|
|
else:
|
|
zoom_text = u''
|
|
|
|
if rotation != 0 and rotation != 360:
|
|
rotation_text = u'(%d°)' % rotation
|
|
else:
|
|
rotation_text = u''
|
|
|
|
return render_to_response('generic_detail.html', {
|
|
'object': document_page,
|
|
'web_theme_hide_menus': True,
|
|
'form': document_page_form,
|
|
'title': u' '.join([base_title, zoom_text, rotation_text]),
|
|
'zoom': zoom,
|
|
'rotation': rotation,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_page_view_reset(request, document_page_id):
|
|
return HttpResponseRedirect(reverse('document_page_view', args=[document_page_id]))
|
|
|
|
|
|
def document_page_text(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
document_page_form = DocumentPageForm_text(instance=document_page)
|
|
|
|
return render_to_response('generic_detail.html', {
|
|
'object': document_page,
|
|
'web_theme_hide_menus': True,
|
|
'form': document_page_form,
|
|
'title': _(u'details for: %s') % document_page,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_page_edit(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_EDIT])
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentPageForm_edit(request.POST, instance=document_page)
|
|
if form.is_valid():
|
|
document_page.page_label = form.cleaned_data['page_label']
|
|
document_page.content = form.cleaned_data['content']
|
|
document_page.save()
|
|
messages.success(request, _(u'Document page edited successfully.'))
|
|
return HttpResponseRedirect(document_page.get_absolute_url())
|
|
else:
|
|
form = DocumentPageForm_edit(instance=document_page)
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'form': form,
|
|
'object': document_page,
|
|
'title': _(u'edit: %s') % document_page,
|
|
'web_theme_hide_menus': True,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_page_navigation_next(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
view = resolve_to_name(urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).path)
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
if document_page.page_number >= document_page.document.documentpage_set.count():
|
|
messages.warning(request, _(u'There are no more pages in this document'))
|
|
return HttpResponseRedirect(request.META.get('HTTP_REFERER', u'/'))
|
|
else:
|
|
document_page = get_object_or_404(DocumentPage, document=document_page.document, page_number=document_page.page_number + 1)
|
|
return HttpResponseRedirect(reverse(view, args=[document_page.pk]))
|
|
|
|
|
|
def document_page_navigation_previous(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
view = resolve_to_name(urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).path)
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
if document_page.page_number <= 1:
|
|
messages.warning(request, _(u'You are already at the first page of this document'))
|
|
return HttpResponseRedirect(request.META.get('HTTP_REFERER', u'/'))
|
|
else:
|
|
document_page = get_object_or_404(DocumentPage, document=document_page.document, page_number=document_page.page_number - 1)
|
|
return HttpResponseRedirect(reverse(view, args=[document_page.pk]))
|
|
|
|
|
|
def document_page_navigation_first(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
view = resolve_to_name(urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).path)
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
document_page = get_object_or_404(DocumentPage, document=document_page.document, page_number=1)
|
|
return HttpResponseRedirect(reverse(view, args=[document_page.pk]))
|
|
|
|
|
|
def document_page_navigation_last(request, document_page_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
view = resolve_to_name(urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).path)
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
document_page = get_object_or_404(DocumentPage, document=document_page.document, page_number=document_page.document.documentpage_set.count())
|
|
return HttpResponseRedirect(reverse(view, args=[document_page.pk]))
|
|
|
|
|
|
def document_list_recent(request):
|
|
return document_list(
|
|
request,
|
|
object_list=[recent_document.document for recent_document in RecentDocument.objects.filter(user=request.user)],
|
|
title=_(u'recent documents'),
|
|
extra_context={
|
|
'recent_count': RECENT_COUNT
|
|
}
|
|
)
|
|
|
|
|
|
def transform_page(request, document_page_id, zoom_function=None, rotation_function=None):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
view = resolve_to_name(urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).path)
|
|
|
|
document_page = get_object_or_404(DocumentPage, pk=document_page_id)
|
|
# Get the query string from the referer url
|
|
query = urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).query
|
|
# Parse the query string and get the zoom value
|
|
# parse_qs return a dictionary whose values are lists
|
|
zoom = int(urlparse.parse_qs(query).get('zoom', ['100'])[0])
|
|
rotation = int(urlparse.parse_qs(query).get('rotation', ['0'])[0])
|
|
|
|
if zoom_function:
|
|
zoom = zoom_function(zoom)
|
|
|
|
if rotation_function:
|
|
rotation = rotation_function(rotation)
|
|
|
|
return HttpResponseRedirect(
|
|
u'?'.join([
|
|
reverse(view, args=[document_page.pk]),
|
|
urlencode({'zoom': zoom, 'rotation': rotation})
|
|
])
|
|
)
|
|
|
|
|
|
def document_page_zoom_in(request, document_page_id):
|
|
return transform_page(
|
|
request,
|
|
document_page_id,
|
|
zoom_function=lambda x: ZOOM_MAX_LEVEL if x + ZOOM_PERCENT_STEP > ZOOM_MAX_LEVEL else x + ZOOM_PERCENT_STEP
|
|
)
|
|
|
|
|
|
def document_page_zoom_out(request, document_page_id):
|
|
return transform_page(
|
|
request,
|
|
document_page_id,
|
|
zoom_function=lambda x: ZOOM_MIN_LEVEL if x - ZOOM_PERCENT_STEP < ZOOM_MIN_LEVEL else x - ZOOM_PERCENT_STEP
|
|
)
|
|
|
|
|
|
def document_page_rotate_right(request, document_page_id):
|
|
return transform_page(
|
|
request,
|
|
document_page_id,
|
|
rotation_function=lambda x: (x + ROTATION_STEP) % 360
|
|
)
|
|
|
|
|
|
def document_page_rotate_left(request, document_page_id):
|
|
return transform_page(
|
|
request,
|
|
document_page_id,
|
|
rotation_function=lambda x: (x - ROTATION_STEP) % 360
|
|
)
|
|
|
|
|
|
def document_print(request, document_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
|
|
RecentDocument.objects.add_document_for_user(request.user, document)
|
|
|
|
post_redirect = None
|
|
next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', post_redirect or document.get_absolute_url())))
|
|
|
|
new_window_url = None
|
|
html_redirect = None
|
|
|
|
if request.method == 'POST':
|
|
form = PrintForm(request.POST)
|
|
if form.is_valid():
|
|
hard_copy_arguments = {}
|
|
# Get page range
|
|
if form.cleaned_data['page_range']:
|
|
hard_copy_arguments['page_range'] = form.cleaned_data['page_range']
|
|
|
|
# Compute page width and height
|
|
if form.cleaned_data['custom_page_width'] and form.cleaned_data['custom_page_height']:
|
|
page_width = form.cleaned_data['custom_page_width']
|
|
page_height = form.cleaned_data['custom_page_height']
|
|
elif form.cleaned_data['page_size']:
|
|
page_width, page_height = dict(PAGE_SIZE_DIMENSIONS)[form.cleaned_data['page_size']]
|
|
|
|
# Page orientation
|
|
if form.cleaned_data['page_orientation'] == PAGE_ORIENTATION_LANDSCAPE:
|
|
page_width, page_height = page_height, page_width
|
|
|
|
hard_copy_arguments['page_width'] = page_width
|
|
hard_copy_arguments['page_height'] = page_height
|
|
|
|
new_url = [reverse('document_hard_copy', args=[document_id])]
|
|
if hard_copy_arguments:
|
|
new_url.append(urlquote(hard_copy_arguments))
|
|
|
|
new_window_url = u'?'.join(new_url)
|
|
new_window_url_name = u'document_hard_copy'
|
|
#html_redirect = next
|
|
#messages.success(request, _(u'Preparing document hardcopy.'))
|
|
else:
|
|
form = PrintForm()
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'form': form,
|
|
'object': document,
|
|
'title': _(u'print: %s') % document,
|
|
'next': next,
|
|
'html_redirect': html_redirect if html_redirect else html_redirect,
|
|
'new_window_url': new_window_url if new_window_url else new_window_url
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_hard_copy(request, document_id):
|
|
#TODO: FIXME
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document = get_object_or_404(Document, pk=document_id)
|
|
|
|
RecentDocument.objects.add_document_for_user(request.user, document)
|
|
|
|
#arguments, warnings = calculate_converter_arguments(document, size=PRINT_SIZE, file_format=DEFAULT_FILE_FORMAT)
|
|
|
|
# Pre-generate
|
|
#convert_document(document, **arguments)
|
|
|
|
# Extract dimension values ignoring any unit
|
|
page_width = request.GET.get('page_width', dict(PAGE_SIZE_DIMENSIONS)[DEFAULT_PAPER_SIZE][0])
|
|
page_height = request.GET.get('page_height', dict(PAGE_SIZE_DIMENSIONS)[DEFAULT_PAPER_SIZE][1])
|
|
|
|
# TODO: Replace with regex to extact numeric portion
|
|
width = float(page_width.split('i')[0].split('c')[0].split('m')[0])
|
|
height = float(page_height.split('i')[0].split('c')[0].split('m')[0])
|
|
|
|
page_range = request.GET.get('page_range', u'')
|
|
if page_range:
|
|
page_range = parse_range(page_range)
|
|
|
|
pages = document.documentpage_set.filter(page_number__in=page_range)
|
|
else:
|
|
pages = document.documentpage_set.all()
|
|
|
|
return render_to_response('document_print.html', {
|
|
'object': document,
|
|
'page_aspect': width / height,
|
|
'page_orientation': PAGE_ORIENTATION_LANDSCAPE if width / height > 1 else PAGE_ORIENTATION_PORTRAIT,
|
|
'page_orientation_landscape': True if width / height > 1 else False,
|
|
'page_orientation_portrait': False if width / height > 1 else True,
|
|
'page_range': page_range,
|
|
'page_width': page_width,
|
|
'page_height': page_height,
|
|
'pages': pages,
|
|
}, context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_list(request):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
context = {
|
|
'object_list': DocumentType.objects.all(),
|
|
'title': _(u'document types'),
|
|
'hide_link': True,
|
|
'list_object_variable_name': 'document_type',
|
|
}
|
|
|
|
return render_to_response('generic_list.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_document_list(request, document_type_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
|
|
document_type = get_object_or_404(DocumentType, pk=document_type_id)
|
|
|
|
return document_list(
|
|
request,
|
|
object_list=Document.objects.filter(document_type=document_type),
|
|
title=_(u'documents of type "%s"') % document_type,
|
|
extra_context={
|
|
'object_name': _(u'document type'),
|
|
'navigation_object_name': 'document_type',
|
|
'document_type': document_type,
|
|
}
|
|
)
|
|
|
|
|
|
def document_type_edit(request, document_type_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_EDIT])
|
|
document_type = get_object_or_404(DocumentType, pk=document_type_id)
|
|
|
|
next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', reverse('document_type_list'))))
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentTypeForm(instance=document_type, data=request.POST)
|
|
if form.is_valid():
|
|
try:
|
|
form.save()
|
|
messages.success(request, _(u'Document type edited successfully'))
|
|
return HttpResponseRedirect(next)
|
|
except Exception, e:
|
|
messages.error(request, _(u'Error editing document type; %s') % e)
|
|
else:
|
|
form = DocumentTypeForm(instance=document_type)
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'title': _(u'edit document type: %s') % document_type,
|
|
'form': form,
|
|
#'object': document_type,
|
|
#'object_name': _(u'document type'),
|
|
'object_name': _(u'document type'),
|
|
'navigation_object_name': 'document_type',
|
|
'document_type': document_type,
|
|
'next': next
|
|
},
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_delete(request, document_type_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_DELETE])
|
|
document_type = get_object_or_404(DocumentType, pk=document_type_id)
|
|
|
|
post_action_redirect = reverse('document_type_list')
|
|
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/')))
|
|
next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/')))
|
|
|
|
if request.method == 'POST':
|
|
try:
|
|
Document.objects.filter(document_type=document_type).update(document_type=None)
|
|
document_type.delete()
|
|
messages.success(request, _(u'Document type: %s deleted successfully.') % document_type)
|
|
except Exception, e:
|
|
messages.error(request, _(u'Document type: %(document_type)s delete error: %(error)s') % {
|
|
'document_type': document_type, 'error': e})
|
|
|
|
return HttpResponseRedirect(next)
|
|
|
|
context = {
|
|
'object_name': _(u'document type'),
|
|
'delete_view': True,
|
|
'previous': previous,
|
|
'next': next,
|
|
|
|
'object_name': _(u'document type'),
|
|
'navigation_object_name': 'document_type',
|
|
'document_type': document_type,
|
|
|
|
'title': _(u'Are you sure you wish to delete the document type: %s?') % document_type,
|
|
'message': _(u'The document type of all documents using this document type will be set to none.'),
|
|
'form_icon': u'layout_delete.png',
|
|
}
|
|
|
|
return render_to_response('generic_confirm.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_create(request):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_CREATE])
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentTypeForm(request.POST)
|
|
if form.is_valid():
|
|
try:
|
|
form.save()
|
|
messages.success(request, _(u'Document type created successfully'))
|
|
return HttpResponseRedirect(reverse('document_type_list'))
|
|
except Exception, e:
|
|
messages.error(request, _(u'Error creating document type; %(error)s') % {
|
|
'error': e})
|
|
else:
|
|
form = DocumentTypeForm()
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'title': _(u'create document type'),
|
|
'form': form,
|
|
},
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_filename_list(request, document_type_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW])
|
|
document_type = get_object_or_404(DocumentType, pk=document_type_id)
|
|
|
|
context = {
|
|
'object_list': document_type.documenttypefilename_set.all(),
|
|
'title': _(u'filenames for document type: %s') % document_type,
|
|
'object_name': _(u'document type'),
|
|
'navigation_object_name': 'document_type',
|
|
'document_type': document_type,
|
|
'list_object_variable_name': 'filename',
|
|
'hide_link': True,
|
|
'extra_columns': [
|
|
{
|
|
'name': _(u'enabled'),
|
|
'attribute': lambda x: two_state_template(x.enabled),
|
|
}
|
|
]
|
|
}
|
|
|
|
return render_to_response('generic_list.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_filename_edit(request, document_type_filename_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_EDIT])
|
|
document_type_filename = get_object_or_404(DocumentTypeFilename, pk=document_type_filename_id)
|
|
|
|
next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', reverse('document_type_filename_list', args=[document_type_filename.document_type_id]))))
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentTypeFilenameForm(instance=document_type_filename, data=request.POST)
|
|
if form.is_valid():
|
|
try:
|
|
document_type_filename.filename = form.cleaned_data['filename']
|
|
document_type_filename.enabled = form.cleaned_data['enabled']
|
|
document_type_filename.save()
|
|
messages.success(request, _(u'Document type filename edited successfully'))
|
|
return HttpResponseRedirect(next)
|
|
except Exception, e:
|
|
messages.error(request, _(u'Error editing document type filename; %s') % e)
|
|
else:
|
|
form = DocumentTypeFilenameForm(instance=document_type_filename)
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'title': _(u'edit filename "%(filename)s" from document type "%(document_type)s"') % {
|
|
'document_type': document_type_filename.document_type, 'filename': document_type_filename
|
|
},
|
|
'form': form,
|
|
'next': next,
|
|
'filename': document_type_filename,
|
|
'document_type': document_type_filename.document_type,
|
|
'navigation_object_list': [
|
|
{'object': 'document_type', 'name': _(u'document type')},
|
|
{'object': 'filename', 'name': _(u'document type filename')}
|
|
],
|
|
},
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_filename_delete(request, document_type_filename_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_EDIT])
|
|
document_type_filename = get_object_or_404(DocumentTypeFilename, pk=document_type_filename_id)
|
|
|
|
post_action_redirect = reverse('document_type_filename_list', args=[document_type_filename.document_type_id])
|
|
|
|
previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/')))
|
|
next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/')))
|
|
|
|
if request.method == 'POST':
|
|
try:
|
|
document_type_filename.delete()
|
|
messages.success(request, _(u'Document type filename: %s deleted successfully.') % document_type_filename)
|
|
except Exception, e:
|
|
messages.error(request, _(u'Document type filename: %(document_type_filename)s delete error: %(error)s') % {
|
|
'document_type_filename': document_type_filename, 'error': e})
|
|
|
|
return HttpResponseRedirect(next)
|
|
|
|
context = {
|
|
'object_name': _(u'document type filename'),
|
|
'delete_view': True,
|
|
'previous': previous,
|
|
'next': next,
|
|
'filename': document_type_filename,
|
|
'document_type': document_type_filename.document_type,
|
|
'navigation_object_list': [
|
|
{'object': 'document_type', 'name': _(u'document type')},
|
|
{'object': 'filename', 'name': _(u'document type filename')}
|
|
],
|
|
'title': _(u'Are you sure you wish to delete the filename: %(filename)s, from document type "%(document_type)s"?') % {
|
|
'document_type': document_type_filename.document_type, 'filename': document_type_filename
|
|
},
|
|
'form_icon': u'database_delete.png',
|
|
}
|
|
|
|
return render_to_response('generic_confirm.html', context,
|
|
context_instance=RequestContext(request))
|
|
|
|
|
|
def document_type_filename_create(request, document_type_id):
|
|
check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_EDIT])
|
|
|
|
document_type = get_object_or_404(DocumentType, pk=document_type_id)
|
|
|
|
if request.method == 'POST':
|
|
form = DocumentTypeFilenameForm_create(request.POST)
|
|
if form.is_valid():
|
|
try:
|
|
document_type_filename = DocumentTypeFilename(
|
|
document_type=document_type,
|
|
filename=form.cleaned_data['filename'],
|
|
enabled=True
|
|
)
|
|
document_type_filename.save()
|
|
messages.success(request, _(u'Document type filename created successfully'))
|
|
return HttpResponseRedirect(reverse('document_type_filename_list', args=[document_type_id]))
|
|
except Exception, e:
|
|
messages.error(request, _(u'Error creating document type filename; %(error)s') % {
|
|
'error': e})
|
|
else:
|
|
form = DocumentTypeFilenameForm_create()
|
|
|
|
return render_to_response('generic_form.html', {
|
|
'title': _(u'create filename for document type: %s') % document_type,
|
|
'form': form,
|
|
'document_type': document_type,
|
|
},
|
|
context_instance=RequestContext(request))
|